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

Merge L4-terrain

Browse Source
This commit is contained in:
Brian Neumann-Fopiano
2026-09-28 12:19:03 -04:00
parent 83c6c66294 2d5da0076c
commit cd61b75ff6
14 changed files with 786 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/src/main/java/art/arcane/iris/generation/cache/ConcurrentClockCache.java
Vendored
+128
View File
@@ -0,0 +1,128 @@
package art.arcane.iris.generation.cache;
import art.arcane.volmlib.util.cache.CacheKey;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.function.Consumer;
/**
* A bounded, lock-free, lossy long-keyed cache for memoized values. Keys hash into 4-way sets and a full set
* evicts with CLOCK (second chance), so reads never write shared state except to set a reference bit once.
* Concurrent inserts of the same key may both compute; the first published value wins.
*/
public final class ConcurrentClockCache<V> {
private static final int WAYS = 4;
private final AtomicReferenceArray<Entry<V>> slots;
private final long sets;
public ConcurrentClockCache(int capacity) {
if (capacity <= 0) {
throw new IllegalArgumentException("Cache capacity must be positive");
}
int setCount = Math.ceilDiv(capacity, WAYS);
sets = setCount;
slots = new AtomicReferenceArray<>(Math.multiplyExact(setCount, WAYS));
}
public int capacity() {
return slots.length();
}
public V get(long key) {
long hash = CacheKey.mix(key);
int base = base(hash);
for (int way = 0; way < WAYS; way++) {
Entry<V> entry = slots.getAcquire(base + way);
if (entry != null && entry.key == key) {
entry.touch();
return entry.value;
}
}
return null;
}
public V putIfAbsent(long key, V value) {
Objects.requireNonNull(value, "Cached value");
long hash = CacheKey.mix(key);
int base = base(hash);
int hand = (int) (hash >>> 60) & (WAYS - 1);
while (true) {
int empty = -1;
for (int way = 0; way < WAYS; way++) {
Entry<V> entry = slots.getAcquire(base + way);
if (entry == null) {
if (empty < 0) {
empty = way;
}
} else if (entry.key == key) {
entry.touch();
return entry.value;
}
}
Entry<V> created = new Entry<>(key, value);
if (empty >= 0) {
if (slots.compareAndSet(base + empty, null, created)) {
return value;
}
continue;
}
int victim = -1;
Entry<V> victimEntry = null;
for (int step = 0; step < WAYS * 2 && victim < 0; step++) {
int way = (hand + step) & (WAYS - 1);
Entry<V> entry = slots.getAcquire(base + way);
if (entry == null || !entry.referenced) {
victim = way;
victimEntry = entry;
} else {
entry.referenced = false;
}
}
if (victim < 0) {
victim = hand;
victimEntry = slots.getAcquire(base + victim);
}
if (slots.compareAndSet(base + victim, victimEntry, created)) {
return value;
}
}
}
public void forEach(Consumer<? super V> action) {
for (int index = 0; index < slots.length(); index++) {
Entry<V> entry = slots.getAcquire(index);
if (entry != null) {
action.accept(entry.value);
}
}
}
public void clear() {
for (int index = 0; index < slots.length(); index++) {
slots.setRelease(index, null);
}
}
private int base(long hash) {
return (int) (((hash & 0xffffffffL) * sets) >>> 32) * WAYS;
}
private static final class Entry<V> {
private final long key;
private final V value;
private boolean referenced;
private Entry(long key, V value) {
this.key = key;
this.value = value;
}
private void touch() {
if (!referenced) {
referenced = true;
}
}
}
}
core/src/main/java/art/arcane/iris/generation/decoration/IrisDepositGenerator.java
+87 -4
View File
@@ -53,6 +53,8 @@ import lombok.experimental.Accessors;
@Description("Creates ore & other block deposits underground")
@Data
public class IrisDepositGenerator {
private static final int FOOTPRINT_MAXIMUM_SIZE = 64;
private static final ThreadLocal<FootprintCells> FOOTPRINT_CELLS = ThreadLocal.withInitial(FootprintCells::new);
private static final long FNV_OFFSET_BASIS = 0xcbf29ce484222325L;
private static final long FNV_PRIME = 0x100000001b3L;
@@ -267,6 +269,42 @@ public class IrisDepositGenerator {
return new IrisObject(1, 1, 1);
}
KSet<BlockPosition> cells = new KSet<>();
vanillaEllipsoidCells(rng, size, (x, y, z) -> cells.add(new BlockPosition(x, y, z)));
return objectFromCells(cells, rng, rdata);
}
/**
* Advances {@code rng} exactly as {@link #getClump(Engine, RNG, IrisData)} would and reports the clump's width
* and lowest block offset without building it, so a caller can reject the clump first and replay the build
* only for clumps it keeps. Returns null without drawing when the shape has no footprint path.
*/
public ClumpFootprint sampleClumpFootprint(RNG rng, IrisData rdata) {
if (shape != IrisDepositShape.VANILLA_ELLIPSOID || minSize > FOOTPRINT_MAXIMUM_SIZE
|| maxSize > FOOTPRINT_MAXIMUM_SIZE) {
return null;
}
int paletteSize = getBlockData(rdata).size();
if (paletteSize == 0) {
return null;
}
int size = rng.i(minSize, maxSize + 1);
if (size <= 0) {
return ClumpFootprint.EMPTY;
}
FootprintCells cells = FOOTPRINT_CELLS.get();
cells.reset();
vanillaEllipsoidCells(rng, size, cells);
if (cells.count == 0) {
return ClumpFootprint.EMPTY;
}
for (int cell = 0; cell < cells.count; cell++) {
rng.i(0, paletteSize);
}
return new ClumpFootprint(cells.extentX * 2 + 1, cells.minY, false);
}
private 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;
@@ -309,7 +347,6 @@ public class IrisDepositGenerator {
}
}
KSet<BlockPosition> cells = new KSet<>();
for (int i = 0; i < size; i++) {
double radius = nodes[i * 4 + 3];
if (radius < 0D) {
@@ -338,14 +375,12 @@ public class IrisDepositGenerator {
for (int z = minZ; z <= maxZ; z++) {
double nz = (z + 0.5D - centerZ) / radius;
if (nx * nx + ny * ny + nz * nz < 1D) {
cells.add(new BlockPosition(x, y, z));
sink.add(x, y, z);
}
}
}
}
}
return objectFromCells(cells, rng, rdata);
}
IrisObject generateVanillaScattered(RNG rng, IrisData rdata, int size) {
@@ -564,4 +599,52 @@ public class IrisDepositGenerator {
record ClumpCacheKey(long depositSeed, int minSize, int maxSize) {
}
@FunctionalInterface
private interface CellSink {
void add(int x, int y, int z);
}
public record ClumpFootprint(int width, int minY, boolean empty) {
static final ClumpFootprint EMPTY = new ClumpFootprint(1, 0, true);
}
private static final class FootprintCells implements CellSink {
private static final int OFFSET = 32;
private static final int AXIS = 64;
private final long[] occupied = new long[AXIS * AXIS * AXIS / 64];
private final int[] touched = new int[AXIS * AXIS * AXIS / 64];
private int touchedCount;
private int count;
private int extentX;
private int minY;
private void reset() {
for (int index = 0; index < touchedCount; index++) {
occupied[touched[index]] = 0L;
}
touchedCount = 0;
count = 0;
extentX = 0;
minY = Integer.MAX_VALUE;
}
@Override
public void add(int x, int y, int z) {
int index = ((x + OFFSET) * AXIS + (y + OFFSET)) * AXIS + (z + OFFSET);
int word = index >>> 6;
long bit = 1L << (index & 63);
long current = occupied[word];
if ((current & bit) != 0L) {
return;
}
if (current == 0L) {
touched[touchedCount++] = word;
}
occupied[word] = current | bit;
count++;
extentX = Math.max(extentX, Math.abs(x));
minY = Math.min(minY, y);
}
}
}
core/src/main/java/art/arcane/iris/generation/decoration/IrisOreGenerator.java
+4 -1
View File
@@ -71,7 +71,10 @@ public class IrisOreGenerator {
return null;
}
CNG chance = chanceCache.aquire(() -> chanceStyle.create(rng, data));
CNG chance = chanceCache.getIfPresent();
if (chance == null) {
chance = chanceCache.aquire(() -> chanceStyle.create(rng, data));
}
if (chance.noise(x, y, z) > threshold) {
return null;
core/src/main/java/art/arcane/iris/generation/mantle/CaveDensityGrid.java
+84
View File
@@ -0,0 +1,84 @@
package art.arcane.iris.generation.mantle;
import art.arcane.iris.generation.cache.ConcurrentClockCache;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceArray;
/**
* Shares the adaptive cave planes' 8-block density lattice between neighbouring chunks. Every lattice column on a
* chunk edge is sampled by two chunks and every corner by four, with identical coordinates and carver noise, so a
* value computed once is reused bit for bit. Racing writers store the same value.
*/
final class CaveDensityGrid {
static final int LATTICE_SHIFT = 3;
private static final int SEGMENT_SHIFT = 5;
private static final int SEGMENT_SIZE = 1 << SEGMENT_SHIFT;
private static final long COORDINATE_MASK = 0xFFFFFFL;
private static final VarHandle VALUES = MethodHandles.arrayElementVarHandle(double[].class);
private static final AtomicInteger OWNERS = new AtomicInteger();
private final ConcurrentClockCache<Column> columns;
CaveDensityGrid(int capacity) {
columns = new ConcurrentClockCache<>(capacity);
}
static int nextOwner() {
return OWNERS.getAndIncrement();
}
Column column(Object owner, int ownerId, int height, int latticeX, int latticeZ) {
long key = (long) (ownerId & 0xFFFF) << 48 | (latticeX & COORDINATE_MASK) << 24 | (latticeZ & COORDINATE_MASK);
Column cached = columns.get(key);
if (cached == null) {
cached = columns.putIfAbsent(key, new Column(owner, latticeX, latticeZ, height));
}
return cached.owner == owner && cached.latticeX == latticeX && cached.latticeZ == latticeZ ? cached : null;
}
void clear() {
columns.clear();
}
static final class Column {
private final Object owner;
private final int latticeX;
private final int latticeZ;
private final AtomicReferenceArray<double[]> segments;
private Column(Object owner, int latticeX, int latticeZ, int height) {
this.owner = owner;
this.latticeX = latticeX;
this.latticeZ = latticeZ;
segments = new AtomicReferenceArray<>(Math.ceilDiv(Math.max(1, height), SEGMENT_SIZE));
}
double get(int y) {
int segment = y >> SEGMENT_SHIFT;
if (segment >= segments.length()) {
return Double.NaN;
}
double[] values = segments.getAcquire(segment);
return values == null ? Double.NaN : (double) VALUES.getOpaque(values, y & (SEGMENT_SIZE - 1));
}
void set(int y, double value) {
int segment = y >> SEGMENT_SHIFT;
if (segment >= segments.length()) {
return;
}
double[] values = segments.getAcquire(segment);
if (values == null) {
double[] created = new double[SEGMENT_SIZE];
Arrays.fill(created, Double.NaN);
double[] published = segments.compareAndExchange(segment, null, created);
values = published == null ? created : published;
}
VALUES.setOpaque(values, y & (SEGMENT_SIZE - 1), value);
}
}
}
core/src/main/java/art/arcane/iris/generation/mantle/IrisCaveCarver3D.java
+39 -11
View File
@@ -61,6 +61,7 @@ public class IrisCaveCarver3D {
private static final int MINIMUM_PARALLEL_DENSITY_CELLS = 16_384;
private static final int MAXIMUM_DENSITY_WORKERS = 4;
private static final int[] LATTICE_TILE_OFFSETS = {0, 1, 16, 17};
private static final int STANDALONE_DENSITY_GRID_COLUMNS = 1024;
private final Engine engine;
private final IrisData data;
@@ -96,9 +97,16 @@ public class IrisCaveCarver3D {
private final int densityMaximumY;
private final ThreadLocal<Boolean> carving = ThreadLocal.withInitial(() -> false);
private final ThreadLocal<CaveCarveScratch> scratchCache = ThreadLocal.withInitial(CaveCarveScratch::new);
private final CaveDensityGrid densityGrid;
private final int densityGridOwner = CaveDensityGrid.nextOwner();
public IrisCaveCarver3D(Engine engine, IrisCaveProfile profile) {
this(engine, profile, new CaveDensityGrid(STANDALONE_DENSITY_GRID_COLUMNS));
}
IrisCaveCarver3D(Engine engine, IrisCaveProfile profile, CaveDensityGrid densityGrid) {
this.engine = engine;
this.densityGrid = densityGrid;
this.data = engine.getData();
this.profile = profile;
this.carveAir = new MatterCavern(true, "", LIQUID_AIR);
@@ -1542,7 +1550,7 @@ public class IrisCaveCarver3D {
int rowOffset = sampleXIndex * axisSamples;
for (int sampleZIndex = adaptivePlaneSampleBounds[2]; sampleZIndex <= adaptivePlaneSampleBounds[3]; sampleZIndex++) {
int sampleLocalZ = Math.min(sampleZIndex * adaptiveSampleStep, 16);
adaptivePlaneDensity[rowOffset + sampleZIndex] = sampleDensityNoWarpNoModules(x, y, z0 + sampleLocalZ);
adaptivePlaneDensity[rowOffset + sampleZIndex] = latticeDensity(scratch, x, y, z0 + sampleLocalZ);
}
}
@@ -1595,7 +1603,7 @@ public class IrisCaveCarver3D {
int rowOffset = sampleXIndex * axisSamples;
for (int sampleZIndex = adaptivePlaneSampleBounds[2]; sampleZIndex <= adaptivePlaneSampleBounds[3]; sampleZIndex++) {
int sampleLocalZ = Math.min(sampleZIndex * adaptiveSampleStep, 16);
adaptivePlaneDensity[rowOffset + sampleZIndex] = sampleDensityNoWarpNoModules(x, y, z0 + sampleLocalZ);
adaptivePlaneDensity[rowOffset + sampleZIndex] = latticeDensity(scratch, x, y, z0 + sampleLocalZ);
}
}
@@ -1643,7 +1651,7 @@ public class IrisCaveCarver3D {
int rowOffset = sampleXIndex * axisSamples;
for (int sampleZIndex = adaptivePlaneSampleBounds[2]; sampleZIndex <= adaptivePlaneSampleBounds[3]; sampleZIndex++) {
int sampleLocalZ = Math.min(sampleZIndex * adaptiveSampleStep, 16);
adaptivePlaneDensity[rowOffset + sampleZIndex] = sampleDensityWarpOnly(scratch, x, y, z0 + sampleLocalZ);
adaptivePlaneDensity[rowOffset + sampleZIndex] = latticeDensity(scratch, x, y, z0 + sampleLocalZ);
}
}
@@ -1696,14 +1704,7 @@ public class IrisCaveCarver3D {
int rowOffset = sampleXIndex * axisSamples;
for (int sampleZIndex = adaptivePlaneSampleBounds[2]; sampleZIndex <= adaptivePlaneSampleBounds[3]; sampleZIndex++) {
int sampleLocalZ = Math.min(sampleZIndex * adaptiveSampleStep, 16);
adaptivePlaneDensity[rowOffset + sampleZIndex] = sampleDensityWarpModules(
scratch,
x,
y,
z0 + sampleLocalZ,
localModules,
activeModuleCount
);
adaptivePlaneDensity[rowOffset + sampleZIndex] = latticeDensity(scratch, x, y, z0 + sampleLocalZ);
}
}
@@ -2463,6 +2464,33 @@ public class IrisCaveCarver3D {
scratch.adaptiveGeometryAxisCells = axisCells;
}
private double latticeDensity(CaveCarveScratch scratch, int x, int y, int z) {
int latticeMask = (1 << CaveDensityGrid.LATTICE_SHIFT) - 1;
CaveDensityGrid.Column column = ((x | z) & latticeMask) != 0 ? null : densityGrid.column(this, densityGridOwner,
densityMaximumY + 1, x >> CaveDensityGrid.LATTICE_SHIFT, z >> CaveDensityGrid.LATTICE_SHIFT);
if (column == null) {
return samplePlaneDensity(scratch, x, y, z);
}
double cached = column.get(y);
if (!Double.isNaN(cached)) {
return cached;
}
double density = samplePlaneDensity(scratch, x, y, z);
column.set(y, density);
return density;
}
private double samplePlaneDensity(CaveCarveScratch scratch, int x, int y, int z) {
if (!hasWarp) {
return sampleDensityNoWarpNoModules(x, y, z);
}
int activeModuleCount = hasModules ? prepareActiveModules(scratch, y) : 0;
if (activeModuleCount == 0) {
return sampleDensityWarpOnly(scratch, x, y, z);
}
return sampleDensityWarpModules(scratch, x, y, z, scratch.activeModules, activeModuleCount);
}
private double sampleDensityNoWarpNoModules(int x, int y, int z) {
double density = baseDensity.noiseFastSigned3D(x, y, z) * baseWeight;
density += detailDensity.noiseFastSigned3D(x, y, z) * detailWeight;
core/src/main/java/art/arcane/iris/generation/mantle/MantleCarvingComponent.java
+5 -1
View File
@@ -54,6 +54,8 @@ public class MantleCarvingComponent extends IrisMantleComponent {
private static final double THRESHOLD_PENALTY = 0.24D;
private static final int MAX_BLENDED_PROFILE_PASSES = 2;
private static final int MAX_POOLED_WEIGHT_BUFFERS = 64;
/** Lattice columns kept for neighbouring chunks: about 3 KB each on land, roughly 50 MB when full. */
private static final int DENSITY_GRID_COLUMNS = 16_384;
private static final int KERNEL_WIDTH = (BLEND_RADIUS * 2) + 1;
private static final int KERNEL_SIZE = KERNEL_WIDTH * KERNEL_WIDTH;
private static final int[] KERNEL_DX = new int[KERNEL_SIZE];
@@ -62,6 +64,7 @@ public class MantleCarvingComponent extends IrisMantleComponent {
private static final ThreadLocal<BlendScratch> BLEND_SCRATCH = ThreadLocal.withInitial(BlendScratch::new);
private final Object profileCarverLock = new Object();
private final CaveDensityGrid densityGrid = new CaveDensityGrid(DENSITY_GRID_COLUMNS);
private volatile Map<IrisCaveProfile, IrisCaveCarver3D> profileCarvers = new IdentityHashMap<>();
static {
@@ -94,6 +97,7 @@ public class MantleCarvingComponent extends IrisMantleComponent {
// Carvers rebuild deterministically from the carve seed, so output is unchanged.
synchronized (profileCarverLock) {
profileCarvers = new IdentityHashMap<>();
densityGrid.clear();
}
}
@@ -524,7 +528,7 @@ public class MantleCarvingComponent extends IrisMantleComponent {
return carver;
}
IrisCaveCarver3D createdCarver = new IrisCaveCarver3D(getEngineMantle().getEngine(), profile);
IrisCaveCarver3D createdCarver = new IrisCaveCarver3D(getEngineMantle().getEngine(), profile, densityGrid);
synchronized (profileCarverLock) {
IrisCaveCarver3D published = profileCarvers.get(profile);
if (published != null) {
core/src/main/java/art/arcane/iris/generation/runtime/IrisComplex.java
+4 -5
View File
@@ -115,7 +115,7 @@ public class IrisComplex implements DataProvider {
private static final AtomicLong lastBoundsFailureLog = new AtomicLong(0L);
private static final int GRID_BOUNDS_CACHE_SIZE = 8192;
private static final int STUDIO_NOISE_CACHE_SIZE = 32_768;
private static final int TERRAIN_COLUMN_CACHE_SIZE = 65_536;
private static final int TERRAIN_COLUMN_CACHE_SIZE = 524_288;
/** One million corners: about 16 MB, roughly a 4000 by 4000 block area at the 4-block grid. */
private static final int SHARED_CORNER_BOUNDS_CAPACITY = 1 << 20;
/** The slope streams measure the rise across a run of this many blocks, so gradient is slope over run. */
@@ -386,10 +386,9 @@ public class IrisComplex implements DataProvider {
proceduralTerrainHeight = new ProceduralTerrainHeightSampler(
(x, z) -> getHeight(engine, x, z, engine.getSeedManager().getHeight()),
engine.getDimension().getTerrainSamplingStep());
baseTerrainHeightStream = GenerationStreams.cache2DDouble(ProceduralStream.of(
this::sampleUnblendedNaturalTerrainHeight,
Interpolated.DOUBLE
), "baseTerrainHeightStream", engine, cacheSize);
baseTerrainHeightStream = GenerationStreams.cache2DDouble(
ProceduralStream.ofDouble(this::sampleUnblendedNaturalTerrainHeight),
"baseTerrainHeightStream", engine, cacheSize);
boolean terrain3DEnabled = false;
for (IrisBiome biome : generatorBiomes) {
if (biome.getTerrain3D() != null) {
core/src/main/java/art/arcane/iris/generation/stage/IrisDepositModifier.java
+123 -9
View File
@@ -23,6 +23,7 @@ import art.arcane.iris.generation.runtime.IrisEngine;
import art.arcane.iris.generation.runtime.EngineAssignedModifier;
import art.arcane.iris.generation.runtime.DimensionStackLayout;
import art.arcane.iris.generation.biome.IrisBiome;
import art.arcane.iris.generation.decoration.IrisDepositBiomeScope;
import art.arcane.iris.generation.decoration.IrisDepositGenerator;
import art.arcane.iris.generation.decoration.IrisDepositHeightDistribution;
import art.arcane.iris.generation.decoration.IrisDepositPlacementScope;
@@ -45,15 +46,20 @@ import art.arcane.volmlib.util.scheduling.PrecisionStopwatch;
import art.arcane.volmlib.nativelib.terrain.NativeBlockState;
import art.arcane.iris.generation.block.B;
import art.arcane.iris.generation.block.VectorMap;
import art.arcane.iris.pack.loading.IrisData;
import art.arcane.iris.pack.loading.IrisRegistrant;
import art.arcane.iris.pack.loading.ResourceLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState> {
private static final int CLUMPS_PER_BATCH = 8;
private static final int PREPARATION_BATCH_COUNT = 4;
private final RNG rng;
private volatile DepositVariantScan variantScan;
public IrisDepositModifier(Engine engine) {
super(engine, "Deposit");
@@ -91,7 +97,7 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
Throwable callerFailure = null;
try {
for (int i = 0; i < generators.size(); i++) {
DepositPlan plan = plan(generators.get(i), rng.nextParallelRNG(seed * (i + 1L)));
DepositPlan plan = plan(generators.get(i), rng.nextParallelRNG(seed * (i + 1L)), context);
for (int first = 0; first < plan.attempts(); first += CLUMPS_PER_BATCH) {
int firstAttempt = first;
int limit = Math.min(plan.attempts(), first + CLUMPS_PER_BATCH);
@@ -163,20 +169,48 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
}
public void generate(IrisDepositGenerator k, MantleChunk chunk, Hunk<NativeBlockState> data, RNG rng, int cx, int cz, boolean safe, HeightMap he, ChunkContext context) {
DepositPlan plan = plan(k, rng);
DepositPlan plan = plan(k, rng, context);
for (int first = 0; first < plan.attempts(); first += CLUMPS_PER_BATCH) {
int limit = Math.min(plan.attempts(), first + CLUMPS_PER_BATCH);
place(prepare(plan, first, limit, cx, cz, he, context), chunk, data, cx, cz, he, context);
}
}
private DepositPlan plan(IrisDepositGenerator generator, RNG rng) {
private DepositPlan plan(IrisDepositGenerator generator, RNG rng, ChunkContext context) {
if (generator.getSpawnChance() < rng.d()) {
return new DepositPlan(generator, rng.getSeed(), false, 0);
}
boolean ore = generator.isOre(getData());
int attempts = rng.i(generator.getMinPerChunk(), generator.getMaxPerChunk() + 1);
return new DepositPlan(generator, rng.getSeed(), ore, attempts);
return new DepositPlan(generator, rng.getSeed(), ore,
attempts == 0 || surfaceBiomeMayMatch(generator, context) ? attempts : 0);
}
/**
* A surface-scoped biome filter reads the surface biome of the clump's own column, so when no column of the
* chunk passes it every clump is rejected at that check. Each clump draws from its own seeded RNG, so skipping
* them all up front changes nothing else.
*/
private static boolean surfaceBiomeMayMatch(IrisDepositGenerator generator, ChunkContext context) {
if (generator.getBiomeScope() != IrisDepositBiomeScope.SURFACE
|| (generator.getIncludedBiomes() == null || generator.getIncludedBiomes().isEmpty())
&& (generator.getExcludedBiomes() == null || generator.getExcludedBiomes().isEmpty())) {
return true;
}
IrisBiome checked = null;
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
IrisBiome surface = context.getBiome().get(x, z);
if (surface == checked) {
continue;
}
if (generator.matchesBiome(surface, null)) {
return true;
}
checked = surface;
}
}
return false;
}
private PreparedDeposit prepare(DepositPlan plan, int first, int limit, int cx, int cz, HeightMap he, ChunkContext context) {
@@ -185,15 +219,18 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
boolean needsCaveBiome = oreDeposit || k.usesCaveBiomeFilter();
IrisDimensionCarvingResolver.State carvingState = needsCaveBiome ? new IrisDimensionCarvingResolver.State() : null;
List<PreparedClump> clumps = new ArrayList<>(limit - first);
int terrainLimit = Integer.MIN_VALUE;
for (int l = first; l < limit; l++) {
RNG clumpRng = new RNG(clumpSeed(plan.seed(), l));
long clumpSeed = clumpSeed(plan.seed(), l);
RNG clumpRng = new RNG(clumpSeed);
if (k.getPerClumpSpawnChance() < clumpRng.d()) {
continue;
}
IrisObject clump = k.getClump(getEngine(), clumpRng, getData());
IrisDepositGenerator.ClumpFootprint footprint = k.sampleClumpFootprint(clumpRng, getData());
IrisObject clump = footprint == null ? k.getClump(getEngine(), clumpRng, getData()) : null;
int dim = clump.getW();
int dim = footprint == null ? clump.getW() : footprint.width();
int min = dim / 2;
int max = (int) (16D - dim / 2D);
@@ -257,6 +294,20 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
}
}
if (clump == null) {
if (k.getPlacementScope() == IrisDepositPlacementScope.TERRAIN && !footprint.empty()) {
if (terrainLimit == Integer.MIN_VALUE) {
terrainLimit = chunkTerrainLimit(cx, cz, he, context, k.getSurfaceClearance());
}
if (y + footprint.minY() > terrainLimit) {
continue;
}
}
RNG replay = new RNG(clumpSeed);
replay.d();
clump = k.getClump(getEngine(), replay, getData());
}
clumps.add(new PreparedClump(clump, x, y, z, clumpRng));
}
return new PreparedDeposit(k, oreDeposit, clumps);
@@ -271,6 +322,7 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
boolean oreDeposit = deposit.ore();
IrisDimensionCarvingResolver.State carvingState = new IrisDimensionCarvingResolver.State();
IrisDimension dimension = getDimension();
boolean variants = depositVariantsPossible();
for (PreparedClump prepared : deposit.clumps()) {
IrisObject clump = prepared.object();
int x = prepared.x();
@@ -325,8 +377,8 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
if (chunk.get(nx, ny, nz, MatterCavern.class) == null) {
NativeBlockState ore = cursor.value();
NativeBlockState remapped = resolveDepositVariant(
cx, cz, nx, ny, nz, ore, dimension, context, carvingState);
NativeBlockState remapped = variants ? resolveDepositVariant(
cx, cz, nx, ny, nz, ore, dimension, context, carvingState) : null;
NativeBlockState finalBlock = remapped != null
? remapped
: B.toDeepSlateOre(current, ore);
@@ -344,6 +396,20 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
: context.getRoundedHeight(localX, localZ);
}
/**
* The highest block a TERRAIN-scoped deposit may place anywhere in the chunk; a clump whose lowest block sits
* above it would have every block rejected by {@link #placementSurfaceAllows}.
*/
private int chunkTerrainLimit(int cx, int cz, HeightMap he, ChunkContext context, int surfaceClearance) {
int highest = Integer.MIN_VALUE;
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
highest = Math.max(highest, getDepositTerrainSurface(cx, cz, x, z, he, context));
}
}
return highest - Math.max(0, surfaceClearance);
}
static int depositSurfaceLimit(int surfaceY) {
return depositSurfaceLimit(surfaceY, 7);
}
@@ -460,6 +526,51 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
return Math.max(minimum, Math.min(center, maximum));
}
/**
* The per-block variant lookup resolves a cave biome for every placed ore, but it can only ever match when
* some biome, region or the dimension of the loaded pack declares variants. Anything the scan cannot
* enumerate (stacked dimensions, unreadable loaders) keeps the lookup.
*/
private boolean depositVariantsPossible() {
IrisData data = getData();
DepositVariantScan scan = variantScan;
if (scan == null || scan.data() != data) {
scan = new DepositVariantScan(data, scanDepositVariants(data));
variantScan = scan;
}
return scan.possible();
}
private boolean scanDepositVariants(IrisData data) {
IrisDimension dimension = getDimension();
if (data == null || dimension == null || getEngine().getDimensionStackContext() != null
|| dimension.getDepositVariants() == null || !dimension.getDepositVariants().isEmpty()) {
return true;
}
Boolean regions = declaresVariants(data.getRegionLoader(), IrisRegion::getDepositVariants);
Boolean biomes = declaresVariants(data.getBiomeLoader(), IrisBiome::getDepositVariants);
return regions == null || regions || biomes == null || biomes;
}
private static <T extends IrisRegistrant> Boolean declaresVariants(ResourceLoader<T> loader,
Function<T, ? extends List<IrisDepositVariant>> variants) {
String[] keys = loader == null ? null : loader.getPossibleKeys();
if (keys == null) {
return null;
}
for (String key : keys) {
T loaded = loader.load(key);
if (loaded == null) {
continue;
}
List<IrisDepositVariant> declared = variants.apply(loaded);
if (declared == null || !declared.isEmpty()) {
return true;
}
}
return false;
}
private NativeBlockState resolveDepositVariant(int cx, int cz, int nx, int localY, int nz, NativeBlockState ore, IrisDimension dimension, ChunkContext context, IrisDimensionCarvingResolver.State carvingState) {
int worldX = (cx << 4) + nx;
int worldZ = (cz << 4) + nz;
@@ -548,6 +659,9 @@ public class IrisDepositModifier extends EngineAssignedModifier<NativeBlockState
private record DepositPlan(IrisDepositGenerator generator, long seed, boolean ore, int attempts) {
}
private record DepositVariantScan(IrisData data, boolean possible) {
}
private record PreparedDeposit(IrisDepositGenerator generator, boolean ore, List<PreparedClump> clumps) {
}
core/src/main/java/art/arcane/iris/generation/terrain/Terrain3DRuntime.java
+68 -82
View File
@@ -1,12 +1,11 @@
package art.arcane.iris.generation.terrain;
import art.arcane.iris.generation.cache.ConcurrentClockCache;
import art.arcane.iris.pack.loading.IrisData;
import art.arcane.iris.generation.biome.IrisBiome;
import art.arcane.iris.generation.noise.IrisGeneratorStyle;
import art.arcane.volmlib.util.noise.CNG;
import art.arcane.volmlib.util.cache.CacheKey;
import art.arcane.volmlib.util.math.RNG;
import it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap;
import java.util.Arrays;
import java.util.IdentityHashMap;
@@ -16,9 +15,10 @@ import java.util.concurrent.atomic.AtomicReferenceArray;
public final class Terrain3DRuntime {
private static final int STEP = 4;
private static final int CACHE_STRIPES = 16;
private static final int MINIMUM_COLUMNS = 16;
private static final int ANCHOR_BLOCK_SIZE = 16;
private static final int MAXIMUM_ANCHORS = 32_768;
private static final long ANCHOR_CACHE_BYTES = 64L * 1024 * 1024;
private static final long ANCHOR_CACHE_BYTES = 128L * 1024 * 1024;
private static final long DENSITY_SALT = 0x536E4A11C924B3D7L;
private static final long CRACK_SALT = 0x7839A16DC4052EFBL;
private static final NodeSample EMPTY_SAMPLE = new NodeSample(0D, 0D, 0D);
@@ -28,10 +28,11 @@ public final class Terrain3DRuntime {
private final Sources sources;
private final Options options;
private final NoiseFactory noiseFactory;
private final BoundedCache<Terrain3DFragmentFilter.DensityColumn> columns;
private final BoundedCache<Anchor> anchors;
private final BlockCache<Terrain3DFragmentFilter.DensityColumn> columns;
private final BlockCache<Anchor> anchors;
private final Terrain3DFragmentFilter fragments;
private final Map<IrisTerrain3D, CompiledProfile> profiles = new IdentityHashMap<>();
private final Object profileLock = new Object();
private volatile Map<IrisTerrain3D, CompiledProfile> profiles = new IdentityHashMap<>();
private final ThreadLocal<ColumnMemo> localColumn = ThreadLocal.withInitial(ColumnMemo::new);
private volatile Object cacheGeneration = new Object();
@@ -46,8 +47,8 @@ public final class Terrain3DRuntime {
this.sources = Objects.requireNonNull(sources, "Terrain sources");
this.options = Objects.requireNonNull(options, "Terrain options");
this.noiseFactory = Objects.requireNonNull(noiseFactory, "Terrain noise factory");
columns = new BoundedCache<>(options.maximumColumns());
anchors = new BoundedCache<>(anchorCacheCapacity(options.height(), options.maximumColumns()));
columns = new BlockCache<>(options.maximumColumns(), 0);
anchors = new BlockCache<>(anchorCacheCapacity(options.height(), options.maximumColumns()), 2);
fragments = new Terrain3DFragmentFilter(this::rawColumn);
}
@@ -59,7 +60,7 @@ public final class Terrain3DRuntime {
long bytesPerAnchor = 160L + 48L * (Math.ceilDiv((long) height, STEP) + 1);
long maximumEntries = Math.min(MAXIMUM_ANCHORS,
Math.min((long) maximumColumns * 8, ANCHOR_CACHE_BYTES / bytesPerAnchor));
return Math.max(CACHE_STRIPES, (int) (maximumEntries / CACHE_STRIPES) * CACHE_STRIPES);
return Math.max(ANCHOR_BLOCK_SIZE, (int) (maximumEntries / ANCHOR_BLOCK_SIZE) * ANCHOR_BLOCK_SIZE);
}
public double height(int x, int z) {
@@ -94,8 +95,8 @@ public final class Terrain3DRuntime {
columns.clear();
anchors.clear();
fragments.clear();
synchronized (profiles) {
profiles.clear();
synchronized (profileLock) {
profiles = new IdentityHashMap<>();
}
cacheGeneration = new Object();
localColumn.remove();
@@ -106,9 +107,8 @@ public final class Terrain3DRuntime {
}
private Terrain3DFragmentFilter.DensityColumn rawColumn(int x, int z) {
long key = pack(x, z);
Terrain3DFragmentFilter.DensityColumn cached = columns.get(key);
return cached == null ? columns.putIfAbsent(key,
Terrain3DFragmentFilter.DensityColumn cached = columns.get(x, z);
return cached == null ? columns.putIfAbsent(x, z,
new Terrain3DFragmentFilter.DensityColumn(createColumn(x, z))) : cached;
}
@@ -196,9 +196,8 @@ public final class Terrain3DRuntime {
}
private Anchor anchor(int x, int z) {
long key = pack(x, z);
Anchor cached = anchors.get(key);
return cached == null ? anchors.putIfAbsent(key, createAnchor(x, z)) : cached;
Anchor cached = anchors.get(x, z);
return cached == null ? anchors.putIfAbsent(x, z, createAnchor(x, z)) : cached;
}
private Anchor createAnchor(int x, int z) {
@@ -227,19 +226,19 @@ public final class Terrain3DRuntime {
if (config == null || !config.isEnabled()) {
return DISABLED;
}
synchronized (profiles) {
CompiledProfile cached = profiles.get(config);
if (cached != null) {
return cached;
}
CompiledProfile cached = profiles.get(config);
if (cached != null) {
return cached;
}
CompiledProfile compiled = compile(config);
synchronized (profiles) {
synchronized (profileLock) {
CompiledProfile existing = profiles.get(config);
if (existing != null) {
return existing;
}
profiles.put(config, compiled);
Map<IrisTerrain3D, CompiledProfile> updated = new IdentityHashMap<>(profiles);
updated.put(config, compiled);
profiles = updated;
return compiled;
}
}
@@ -314,7 +313,7 @@ public final class Terrain3DRuntime {
boolean enabled, int maximumColumns) {
public Options {
if (height < 2 || height > 4096 || !Double.isFinite(fluidHeight)
|| maximumColumns < CACHE_STRIPES) {
|| maximumColumns < MINIMUM_COLUMNS) {
throw new IllegalArgumentException("Invalid volumetric terrain runtime options");
}
}
@@ -408,74 +407,61 @@ public final class Terrain3DRuntime {
double fluidFade, NoiseSource density, NoiseSource cracks) {
}
private static final class BoundedCache<T> {
private final CacheStripe<T>[] stripes;
/**
* Groups the 16x16 block area of one chunk into a single cache entry, so neighbouring lookups share one
* lock-free set probe and a working set of whole chunks is evicted together.
*/
private static final class BlockCache<T> {
private final ConcurrentClockCache<AtomicReferenceArray<T>> blocks;
private final int cellShift;
private final int axisMask;
private final int axisBits;
@SuppressWarnings("unchecked")
private BoundedCache(int maximumSize) {
stripes = (CacheStripe<T>[]) new CacheStripe<?>[CACHE_STRIPES];
for (int index = 0; index < stripes.length; index++) {
stripes[index] = new CacheStripe<>(Math.ceilDiv(maximumSize, CACHE_STRIPES));
private BlockCache(int maximumEntries, int cellShift) {
this.cellShift = cellShift;
axisBits = 4 - cellShift;
axisMask = (1 << axisBits) - 1;
int blockSize = 1 << (axisBits * 2);
blocks = new ConcurrentClockCache<>(Math.ceilDiv(maximumEntries, blockSize));
}
private T get(int x, int z) {
AtomicReferenceArray<T> block = blocks.get(blockKey(x, z));
return block == null ? null : block.getAcquire(slot(x, z));
}
private T putIfAbsent(int x, int z, T value) {
long key = blockKey(x, z);
AtomicReferenceArray<T> block = blocks.get(key);
if (block == null) {
block = blocks.putIfAbsent(key, new AtomicReferenceArray<>(1 << (axisBits * 2)));
}
}
private T get(long key) {
return stripe(key).get(key);
}
private T putIfAbsent(long key, T value) {
return stripe(key).putIfAbsent(key, value);
T existing = block.compareAndExchange(slot(x, z), null, value);
return existing == null ? value : existing;
}
private void clear() {
for (CacheStripe<T> stripe : stripes) {
stripe.clear();
}
blocks.clear();
}
private int size() {
int size = 0;
for (CacheStripe<T> stripe : stripes) {
size += stripe.size();
}
return size;
int[] size = new int[1];
blocks.forEach(block -> {
for (int index = 0; index < block.length(); index++) {
if (block.getAcquire(index) != null) {
size[0]++;
}
}
});
return size[0];
}
private CacheStripe<T> stripe(long key) {
return stripes[(int) CacheKey.mix(key) & (CACHE_STRIPES - 1)];
}
}
private static final class CacheStripe<T> {
private final int maximumSize;
private final Long2ObjectLinkedOpenHashMap<T> entries = new Long2ObjectLinkedOpenHashMap<>(16);
private CacheStripe(int maximumSize) {
this.maximumSize = maximumSize;
private static long blockKey(int x, int z) {
return pack(x >> 4, z >> 4);
}
private synchronized T get(long key) {
return entries.getAndMoveToLast(key);
}
private synchronized T putIfAbsent(long key, T value) {
T existing = entries.getAndMoveToLast(key);
if (existing != null) {
return existing;
}
entries.putAndMoveToLast(key, value);
if (entries.size() > maximumSize) {
entries.removeFirst();
}
return value;
}
private synchronized void clear() {
entries.clear();
}
private synchronized int size() {
return entries.size();
private int slot(int x, int z) {
return ((x >> cellShift) & axisMask) << axisBits | ((z >> cellShift) & axisMask);
}
}
}
core/src/test/java/art/arcane/iris/generation/cache/ConcurrentClockCacheTest.java
Vendored
+84
View File
@@ -0,0 +1,84 @@
package art.arcane.iris.generation.cache;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
public class ConcurrentClockCacheTest {
@Test
public void firstPublishedValueWins() {
ConcurrentClockCache<Object> cache = new ConcurrentClockCache<>(16);
Object first = new Object();
assertNull(cache.get(7L));
assertSame(first, cache.putIfAbsent(7L, first));
assertSame(first, cache.putIfAbsent(7L, new Object()));
assertSame(first, cache.get(7L));
cache.clear();
assertNull(cache.get(7L));
}
@Test
public void capacityBoundsRetainedEntries() {
ConcurrentClockCache<Long> cache = new ConcurrentClockCache<>(64);
for (long key = 0; key < 10_000; key++) {
assertEquals(Long.valueOf(key), cache.putIfAbsent(key, key));
}
AtomicInteger retained = new AtomicInteger();
cache.forEach(value -> {
retained.incrementAndGet();
assertEquals(value, cache.get(value));
});
assertEquals(cache.capacity(), retained.get());
assertTrue(cache.capacity() >= 64);
}
@Test
public void referencedEntriesSurviveAStreamOfOneTimeKeys() {
ConcurrentClockCache<Long> cache = new ConcurrentClockCache<>(4);
cache.putIfAbsent(-1L, -1L);
for (long key = 0; key < 1_000; key++) {
assertEquals(Long.valueOf(-1L), cache.get(-1L));
cache.putIfAbsent(key, key);
}
assertEquals(Long.valueOf(-1L), cache.get(-1L));
}
@Test
public void concurrentWritersAgreeOnOneValuePerKey() throws Exception {
ConcurrentClockCache<Object> cache = new ConcurrentClockCache<>(1 << 12);
List<Future<Object[]>> results = new ArrayList<>();
try (ExecutorService executor = Executors.newFixedThreadPool(8)) {
for (int thread = 0; thread < 8; thread++) {
results.add(executor.submit(() -> {
Object[] seen = new Object[256];
for (int key = 0; key < seen.length; key++) {
seen[key] = cache.putIfAbsent(key, new Object());
}
return seen;
}));
}
Object[] reference = results.getFirst().get(10, TimeUnit.SECONDS);
for (Future<Object[]> result : results) {
Object[] seen = result.get(10, TimeUnit.SECONDS);
for (int key = 0; key < seen.length; key++) {
Object cached = cache.get(key);
if (cached != null) {
assertSame(cached, seen[key]);
assertSame(reference[key], seen[key]);
}
}
}
}
}
}
core/src/test/java/art/arcane/iris/generation/decoration/IrisDepositTuningTest.java
+34
View File
@@ -2,6 +2,8 @@ package art.arcane.iris.generation.decoration;
import art.arcane.iris.generation.biome.IrisBiome;
import art.arcane.iris.generation.block.IrisBlockData;
import art.arcane.iris.generation.block.VectorMap;
import art.arcane.iris.structure.object.IrisObject;
import art.arcane.iris.pack.loading.IrisData;
import art.arcane.volmlib.util.documentation.Description;
@@ -224,6 +226,38 @@ public class IrisDepositTuningTest {
assertNotEquals(17L * samples, largeBlocks);
}
@Test
public void ellipsoidFootprintConsumesTheBuildDrawsAndMatchesItsGeometry() {
IrisData data = mock(IrisData.class);
IrisDepositGenerator generator = generatorWithState(data, true);
generator.setShape(IrisDepositShape.VANILLA_ELLIPSOID);
for (int size : new int[]{0, 1, 3, 4, 9, 17, 25, 64}) {
generator.setMinSize(size).setMaxSize(size);
for (long seed = 0; seed < 300; seed++) {
RNG built = new RNG(seed);
IrisObject clump = generator.getClump(null, built, data);
RNG sampled = new RNG(seed);
IrisDepositGenerator.ClumpFootprint footprint = generator.sampleClumpFootprint(sampled, data);
assertNotNull(footprint);
assertEquals(clump.getW(), footprint.width());
assertEquals(clump.getBlocks().size() == 0, footprint.empty());
if (!footprint.empty()) {
int minimumY = Integer.MAX_VALUE;
VectorMap<NativeBlockState>.Cursor cursor = clump.getBlocks().cursor();
while (cursor.next()) {
minimumY = Math.min(minimumY, cursor.key().getBlockY());
}
assertEquals(minimumY, footprint.minY());
}
assertEquals(built.nextLong(), sampled.nextLong());
}
}
generator.setMinSize(65).setMaxSize(65);
assertNull(generator.sampleClumpFootprint(new RNG(1L), data));
generator.setShape(IrisDepositShape.VANILLA_SCATTERED).setMinSize(4).setMaxSize(4);
assertNull(generator.sampleClumpFootprint(new RNG(1L), data));
}
@Test
public void vanillaScatteredSizeIsAnUpperCandidateBound() {
IrisData data = mock(IrisData.class);
core/src/test/java/art/arcane/iris/generation/mantle/IrisCaveCarver3DNearParityTest.java
+34
View File
@@ -1038,6 +1038,40 @@ public class IrisCaveCarver3DNearParityTest {
largestPlane < 192);
}
@Test
public void sharedDensityLatticeReproducesIsolatedCarvesAcrossNeighbourChunks() throws Exception {
Engine engine = createEngine(96, 90);
for (boolean warp : new boolean[]{false, true}) {
for (boolean modules : new boolean[]{false, true}) {
AtomicLong sharedSamples = new AtomicLong();
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));
for (int chunkX = -1; chunkX <= 1; chunkX++) {
for (int chunkZ = -1; chunkZ <= 1; chunkZ++) {
WriterCapture sharedCapture = createWriterCapture(96);
int sharedCarved = shared.carve(sharedCapture.writer, chunkX, chunkZ, fullWeights(), 0D, 0D,
null, filledHeights(90));
IrisCaveCarver3D isolated = new IrisCaveCarver3D(engine,
createProfile(warp, modules).setAdaptiveSampling(true));
baseDensityField.set(isolated, new CountingCNG((CNG) baseDensityField.get(isolated), isolatedSamples));
WriterCapture isolatedCapture = createWriterCapture(96);
int isolatedCarved = isolated.carve(isolatedCapture.writer, chunkX, chunkZ, fullWeights(), 0D, 0D,
null, filledHeights(90));
assertTrue(isolatedCarved > 0);
assertEquals(isolatedCarved, sharedCarved);
assertEquals(isolatedCapture.carvedCells, sharedCapture.carvedCells);
assertEquals(isolatedCapture.carvedLiquids, sharedCapture.carvedLiquids);
}
}
assertTrue("warp=" + warp + " modules=" + modules + " shared=" + sharedSamples.get()
+ " isolated=" + isolatedSamples.get(),
sharedSamples.get() < isolatedSamples.get() * 3 / 4);
}
}
}
private void assertExactParity(boolean warp, boolean modules, boolean adaptiveSampling) throws Exception {
Engine engine = createEngine(96, 90);
double[] columnWeights = fullWeights();
core/src/test/java/art/arcane/iris/generation/stage/IrisDepositModifierParityTest.java
+88 -3
View File
@@ -5,12 +5,14 @@ import art.arcane.iris.testsupport.KeyedBlockState;
import art.arcane.iris.pack.loading.IrisData;
import art.arcane.iris.generation.runtime.Engine;
import art.arcane.iris.generation.biome.IrisBiome;
import art.arcane.iris.generation.decoration.IrisDepositBiomeScope;
import art.arcane.iris.generation.decoration.IrisDepositGenerator;
import art.arcane.iris.generation.decoration.IrisDepositHeightDistribution;
import art.arcane.iris.generation.decoration.IrisDepositShape;
import art.arcane.iris.generation.decoration.IrisDepositVariant;
import art.arcane.iris.generation.terrain.IrisDimension;
import art.arcane.iris.generation.terrain.IrisRegion;
import art.arcane.iris.structure.object.IrisObject;
import art.arcane.iris.spi.IrisPlatform;
import art.arcane.iris.spi.IrisPlatforms;
import art.arcane.volmlib.nativelib.terrain.NativeBlockState;
@@ -25,17 +27,21 @@ import art.arcane.volmlib.util.mantle.runtime.Mantle;
import art.arcane.volmlib.util.mantle.runtime.MantleChunk;
import art.arcane.volmlib.util.matter.Matter;
import art.arcane.volmlib.util.matter.MatterCavern;
import art.arcane.volmlib.util.math.RNG;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
import org.mockito.MockedStatic;
import art.arcane.iris.pack.loading.ResourceLoader;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -84,8 +90,38 @@ public class IrisDepositModifierParityTest {
}
}
@SuppressWarnings("unchecked")
@Test
public void variantFreePacksSkipPerBlockCaveBiomeLookupsWithIdenticalOutput() {
for (long seed : new long[]{101L, -73L, 90181L}) {
AtomicInteger scannedLookups = new AtomicInteger();
AtomicInteger unscannedLookups = new AtomicInteger();
long[] scanned = generateConfigured(seed, false, false, true, scannedLookups);
long[] unscanned = generateConfigured(seed, false, false, false, unscannedLookups);
assertArrayEquals("seed=" + seed, unscanned, scanned);
assertTrue(scannedLookups.get() < unscannedLookups.get());
}
}
@Test
public void unmatchableSurfaceBiomeFiltersSkipClumpsWithoutChangingOutput() {
long[] expected = {-4609692219192155345L, 784L, 2118L, 53L, 67L, 11L};
AtomicInteger clumps = new AtomicInteger();
assertArrayEquals(expected, generateConfigured(101L, false, true, false, new AtomicInteger(), clumps));
assertEquals(0, clumps.get());
}
private long[] generateConfigured(long seed, boolean multicore) {
return generateConfigured(seed, multicore, true, false, new AtomicInteger());
}
private long[] generateConfigured(long seed, boolean multicore, boolean caveVariant, boolean enumerablePack,
AtomicInteger caveBiomeLookups) {
return generateConfigured(seed, multicore, caveVariant, enumerablePack, caveBiomeLookups, null);
}
@SuppressWarnings("unchecked")
private long[] generateConfigured(long seed, boolean multicore, boolean caveVariant, boolean enumerablePack,
AtomicInteger caveBiomeLookups, AtomicInteger unmatchableClumps) {
Engine engine = mock(Engine.class, RETURNS_DEEP_STUBS);
ChunkContext context = mock(ChunkContext.class, RETURNS_DEEP_STUBS);
IrisDimension dimension = new IrisDimension();
@@ -99,7 +135,9 @@ public class IrisDepositModifierParityTest {
denied.setLoadKey("denied");
IrisDepositVariant variant = new IrisDepositVariant().setMinHeight(-64).setMaxHeight(64);
variant.getRemap().put("minecraft:gold_ore", "minecraft:redstone_ore");
cave.getDepositVariants().add(variant);
if (caveVariant) {
cave.getDepositVariants().add(variant);
}
dimension.getDeposits().add(generator("granite", IrisDepositShape.IRIS, 25, 70,
IrisDepositHeightDistribution.CLIPPED_UNIFORM, "stone", "deepslate"));
region.getDeposits().add(generator("iron_ore", IrisDepositShape.VANILLA_ELLIPSOID, 20, 110,
@@ -114,11 +152,37 @@ public class IrisDepositModifierParityTest {
gold.setExcludedBiomes(new KList<>("allowed"));
gold.setDiscardChanceOnAirExposure(0.3D);
surface.getDeposits().add(gold);
if (unmatchableClumps != null) {
IrisDepositGenerator unmatchable = new CountingPaletteGenerator(state("emerald_ore"), unmatchableClumps)
.setShape(IrisDepositShape.VANILLA_ELLIPSOID).setMinSize(9).setMaxSize(9)
.setMinPerChunk(90).setMaxPerChunk(90).setMinHeight(-4).setMaxHeight(44)
.setHeightDistribution(IrisDepositHeightDistribution.UNIFORM).setSurfaceClearance(0)
.setReplaceableBlocks(new KList<>("stone"))
.setBiomeScope(IrisDepositBiomeScope.SURFACE)
.setIncludedBiomes(new KList<>("elsewhere"));
surface.getDeposits().add(unmatchable);
}
when(engine.getHeight()).thenReturn(48);
when(engine.getMinHeight()).thenReturn(-64);
when(engine.getSeedManager().getDeposit()).thenReturn(seed);
when(engine.getDimension()).thenReturn(dimension);
if (enumerablePack) {
IrisData data = mock(IrisData.class);
ResourceLoader<IrisBiome> biomes = mock(ResourceLoader.class);
ResourceLoader<IrisRegion> regions = mock(ResourceLoader.class);
when(data.getBiomeLoader()).thenReturn(biomes);
when(data.getRegionLoader()).thenReturn(regions);
when(biomes.getPossibleKeys()).thenReturn(new String[]{"allowed", "denied", "surface"});
when(biomes.load("allowed")).thenReturn(cave);
when(biomes.load("denied")).thenReturn(denied);
when(biomes.load("surface")).thenReturn(surface);
when(regions.getPossibleKeys()).thenReturn(new String[]{"region"});
when(regions.load("region")).thenReturn(region);
when(engine.getData()).thenReturn(data);
when(engine.getDimensionStackContext()).thenReturn(null);
}
when(engine.getCaveBiome(anyInt(), anyInt(), anyInt(), any())).thenAnswer(invocation -> {
caveBiomeLookups.incrementAndGet();
int x = invocation.getArgument(0);
int y = invocation.getArgument(1);
int z = invocation.getArgument(2);
@@ -366,7 +430,7 @@ public class IrisDepositModifierParityTest {
}
}
private static final class PaletteGenerator extends IrisDepositGenerator {
private static class PaletteGenerator extends IrisDepositGenerator {
private final KList<NativeBlockState> blocks;
private PaletteGenerator(NativeBlockState block) {
@@ -378,4 +442,25 @@ public class IrisDepositModifierParityTest {
return blocks;
}
}
private static final class CountingPaletteGenerator extends PaletteGenerator {
private final AtomicInteger clumps;
private CountingPaletteGenerator(NativeBlockState block, AtomicInteger clumps) {
super(block);
this.clumps = clumps;
}
@Override
public IrisObject getClump(Engine engine, RNG rng, IrisData data) {
clumps.incrementAndGet();
return super.getClump(engine, rng, data);
}
@Override
public ClumpFootprint sampleClumpFootprint(RNG rng, IrisData data) {
clumps.incrementAndGet();
return super.sampleClumpFootprint(rng, data);
}
}
}
core/src/test/java/art/arcane/iris/generation/terrain/Terrain3DRuntimeTest.java
+4 -3
View File
@@ -302,7 +302,7 @@ public class Terrain3DRuntimeTest {
assertEquals(0, capacity % 16);
assertTrue(capacity >= 16);
assertTrue(capacity <= 32_768);
assertTrue(capacity * fullHeightStorage <= 64L * 1024 * 1024);
assertTrue(capacity * fullHeightStorage <= 128L * 1024 * 1024);
}
}
}
@@ -354,9 +354,10 @@ public class Terrain3DRuntimeTest {
for (int x = -65_536; x < 65_536; x++) {
assertEquals(96, runtime.column(x, -1).topY());
}
assertEquals(65_536, runtime.cachedColumnCount());
assertTrue(runtime.cachedColumnCount() > 0);
assertTrue(runtime.cachedColumnCount() <= 65_536);
assertEquals(96, runtime.column(-65_536, -1).topY());
assertEquals(65_536, runtime.cachedColumnCount());
assertTrue(runtime.cachedColumnCount() <= 65_536);
runtime.clear();
assertEquals(0, runtime.cachedColumnCount());
}