okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1a97146aa3ba6ce89c7fa3f196558ba43ce034ff
EVEngine/test/procgen_cave.cpp
T

2811 lines
141 KiB
C++
Raw Blame History

#include "zeroerr/unittest.h"
#include "procgen/Params.h"
#include "procgen/algorithms/CaveAbrasion.h"
#include "procgen/algorithms/CaveBiogenicCorrosion.h"
#include "procgen/algorithms/CaveBoundary.h"
#include "procgen/algorithms/CaveBreakdown.h"
#include "procgen/algorithms/CaveCondensation.h"
#include "procgen/algorithms/CaveConstrictionScour.h"
#include "procgen/algorithms/CaveDepositAnchoring.h"
#include "procgen/algorithms/CaveDifferentialErosion.h"
#include "procgen/algorithms/CaveFacets.h"
#include "procgen/algorithms/CaveFieldSampling.h"
#include "procgen/algorithms/CaveFractureChannelization.h"
#include "procgen/algorithms/CaveFractures.h"
#include "procgen/algorithms/CaveKarren.h"
#include "procgen/algorithms/CaveKnickpoint.h"
#include "procgen/algorithms/CaveLithology.h"
#include "procgen/algorithms/CaveMineralArmoring.h"
#include "procgen/algorithms/CaveMixingCorrosion.h"
#include "procgen/algorithms/CaveObstacleScour.h"
#include "procgen/algorithms/CavePlucking.h"
#include "procgen/algorithms/CavePotholes.h"
#include "procgen/algorithms/CaveReactivePatchiness.h"
#include "procgen/algorithms/CaveRoughness.h"
#include "procgen/algorithms/CaveRoughnessTransfer.h"
#include "procgen/algorithms/CaveScallopHistory.h"
#include "procgen/algorithms/CaveScallops.h"
#include "procgen/algorithms/CaveSediment.h"
#include "procgen/algorithms/CaveSupport.h"
#include "procgen/algorithms/CaveSurfaceEvolution.h"
#include "procgen/algorithms/CaveSurfaceReactivity.h"
#include "procgen/algorithms/CaveWaterTable.h"
#include "procgen/algorithms/CaveWetness.h"
#include "procgen/algorithms/MarchingCubes.h"
#include <cmath>
#include <limits>
#include <string>
#include <vector>
using namespace eve::procgen;
TEST_CASE("procgen.mesh.cave.correlatedReactivePatchesAreCoherentSeededAndSurfaceBound") {
constexpr int size = 21;
std::vector<float> first(size_t(size * size * size));
std::vector<float> rates(first.size(), 1.f);
std::vector<CaveHydrologyVec3> flow(first.size(), {1.f, 0.f, 0.f});
for (int z = 0; z < size; ++z) {
for (int y = 0; y < size; ++y) {
for (int x = 0; x < size; ++x) {
const float px = float(x) / float(size - 1) * 2.f - 1.f;
first[size_t(x + y * size + z * size * size)] = px;
}
}
}
std::vector<float> repeated = first;
std::vector<float> otherSeed = first;
const auto result = evolveCaveSurfaceByCorrelatedReactivity(first, rates, flow, size, size, size, 1.f, 20260830u);
const auto repeatedResult =
evolveCaveSurfaceByCorrelatedReactivity(repeated, rates, flow, size, size, size, 1.f, 20260830u);
const auto otherResult =
evolveCaveSurfaceByCorrelatedReactivity(otherSeed, rates, flow, size, size, size, 1.f, 20260831u);
CHECK(first == repeated);
CHECK(first != otherSeed);
CHECK_EQ(result.totalRetreat, repeatedResult.totalRetreat);
CHECK(result.affectedVoxels > 0);
CHECK(otherResult.affectedVoxels > 0);
CHECK(result.minimumPatchRate < 1.f);
CHECK(result.maximumPatchRate > 1.f);
CHECK(result.meanNeighborCoherence > 0.8f);
CHECK(result.meanFlowCoherence > result.meanTransverseCoherence);
CHECK(result.channelAnisotropy > 1.5f);
CHECK_EQ(first.front(), -1.f);
CHECK_EQ(first.back(), 1.f);
}
TEST_CASE("procgen.mesh.cave.reactivePatchinessIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 32);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
MeshBuild omitted, disabled, patched, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("reactivePatchiness", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, disabled, error));
CHECK(omitted.positions() == disabled.positions());
CHECK(omitted.indices() == disabled.indices());
params.setFloat("reactivePatchiness", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, patched, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(disabled.positions() != patched.positions());
CHECK(patched.positions() == repeated.positions());
CHECK(patched.indices() == repeated.indices());
CHECK_EQ(patched.getMeta("reactivePatchModel", ""), std::string("flow-aligned-correlated-psd-v2"));
CHECK(std::stoi(patched.getMeta("reactivePatchAffectedVoxels", "0")) > 0);
CHECK(std::stof(patched.getMeta("maximumReactivePatchRate", "0")) > 1.f);
CHECK(std::stof(patched.getMeta("minimumReactivePatchRate", "1")) < 1.f);
CHECK(std::stof(patched.getMeta("reactivePatchNeighborCoherence", "0")) > 0.8f);
CHECK(std::stof(patched.getMeta("reactivePatchFlowCoherence", "0")) >
std::stof(patched.getMeta("reactivePatchTransverseCoherence", "1")));
CHECK(std::stof(patched.getMeta("reactivePatchChannelAnisotropy", "0")) > 1.f);
params.setFloat("reactivePatchiness", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.surfaceReactivityDistinguishesEdgesFromPlanesRotationInvariantly") {
constexpr int size = 15;
std::vector<float> plane(size_t(size * size * size));
std::vector<float> corner(size_t(size * size * size));
std::vector<float> rotatedCorner(size_t(size * size * size));
std::vector<float> rates(plane.size(), 1.f);
for (int z = 0; z < size; ++z) {
for (int y = 0; y < size; ++y) {
for (int x = 0; x < size; ++x) {
const float px = float(x) / float(size - 1) * 2.f - 1.f;
const float py = float(y) / float(size - 1) * 2.f - 1.f;
const float pz = float(z) / float(size - 1) * 2.f - 1.f;
const size_t index = size_t(x + y * size + z * size * size);
plane[index] = px;
corner[index] = std::max(px, py);
rotatedCorner[index] = std::max((px + py) * 0.70710678f, pz);
}
}
}
std::vector<float> repeated = corner;
const auto planeResult = evolveCaveSurfaceByReactivity(plane, rates, size, size, size, 1.f);
const auto cornerResult = evolveCaveSurfaceByReactivity(corner, rates, size, size, size, 1.f);
const auto repeatedResult = evolveCaveSurfaceByReactivity(repeated, rates, size, size, size, 1.f);
const auto rotatedResult = evolveCaveSurfaceByReactivity(rotatedCorner, rates, size, size, size, 1.f);
CHECK_EQ(planeResult.affectedVoxels, 0);
CHECK(cornerResult.affectedVoxels > 0);
CHECK(rotatedResult.affectedVoxels > 0);
CHECK(cornerResult.maximumNormalDispersion > 0.2f);
CHECK(rotatedResult.maximumNormalDispersion > 0.2f);
CHECK(corner == repeated);
CHECK_EQ(cornerResult.affectedVoxels, repeatedResult.affectedVoxels);
CHECK_EQ(cornerResult.totalRetreat, repeatedResult.totalRetreat);
}
TEST_CASE("procgen.mesh.cave.surfaceSlopeReactivityIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 34);
params.setInt("chambers", 6);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.18f);
params.setFloat("multiscaleRoughness", 1.f);
MeshBuild omitted, disabled, reactive, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("surfaceSlopeReactivity", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, disabled, error));
CHECK(omitted.positions() == disabled.positions());
CHECK(omitted.indices() == disabled.indices());
params.setFloat("surfaceSlopeReactivity", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, reactive, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(disabled.positions() != reactive.positions());
CHECK(reactive.positions() == repeated.positions());
CHECK(reactive.indices() == repeated.indices());
CHECK_EQ(reactive.getMeta("surfaceReactivityModel", ""), std::string("rotation-invariant-normal-dispersion-v1"));
CHECK(std::stoi(reactive.getMeta("surfaceReactivityAffectedVoxels", "0")) > 0);
CHECK(std::stof(reactive.getMeta("maximumSurfaceNormalDispersion", "0")) > 0.f);
CHECK(std::stof(reactive.getMeta("maximumSurfaceReactivityRetreat", "0")) > 0.f);
params.setFloat("surfaceSlopeReactivity", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.roughnessTransferExposesRidgesAndSheltersRecesses") {
const CaveRoughnessTransferSample disabled = sampleCaveRoughnessTransfer({0.8f, 1.f, 0.f});
CHECK_EQ(disabled.massTransferMultiplier, 1.f);
const CaveRoughnessTransferSample ridge = sampleCaveRoughnessTransfer({0.8f, 1.f, 1.f});
const CaveRoughnessTransferSample recess = sampleCaveRoughnessTransfer({-0.8f, 1.f, 1.f});
const CaveRoughnessTransferSample flushedRecess = sampleCaveRoughnessTransfer({-0.8f, 2.f, 1.f});
CHECK(ridge.massTransferMultiplier > 1.f);
CHECK(recess.massTransferMultiplier < 1.f);
CHECK(flushedRecess.massTransferMultiplier > recess.massTransferMultiplier);
CHECK(ridge.ridgeExposure > 0.f);
CHECK(recess.recessShelter > 0.f);
CHECK(ridge.massTransferMultiplier <= 1.45f);
CHECK(recess.massTransferMultiplier >= 0.60f);
CHECK_EQ(ridge.massTransferMultiplier, sampleCaveRoughnessTransfer({0.8f, 1.f, 1.f}).massTransferMultiplier);
}
TEST_CASE("procgen.mesh.cave.roughnessFlowCouplingIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.16f);
params.setFloat("multiscaleRoughness", 1.f);
params.setFloat("erosion", 1.f);
MeshBuild omitted, disabled, coupled, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("roughnessFlowCoupling", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, disabled, error));
CHECK(omitted.positions() == disabled.positions());
CHECK(omitted.indices() == disabled.indices());
params.setFloat("roughnessFlowCoupling", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, coupled, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(disabled.positions() != coupled.positions());
CHECK(coupled.positions() == repeated.positions());
CHECK(coupled.indices() == repeated.indices());
CHECK_EQ(coupled.getMeta("roughnessMassTransferModel", ""), std::string("ridge-exposure-recess-shelter-v1"));
CHECK(std::stoi(coupled.getMeta("roughnessTransferAffectedVoxels", "0")) > 0);
CHECK(std::stof(coupled.getMeta("minimumRoughnessTransferMultiplier", "1")) < 1.f);
CHECK(std::stof(coupled.getMeta("maximumRoughnessTransferMultiplier", "1")) > 1.f);
params.setFloat("multiscaleRoughness", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK_EQ(repeated.getMeta("roughnessMassTransferModel", ""), std::string("inactive-no-resolved-relief"));
params.setFloat("roughnessFlowCoupling", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.scallopHistoryPreservesOlderReliefAndAddsPartitionedYoungerFlow") {
CaveScallopInput base;
base.along = 0.42f;
base.angle = 0.65f;
base.distance = 0.17f;
base.radius = 0.18f;
base.hydraulicIntensity = 1.2f;
base.baseScale = 0.12f;
base.flowSeparation = 0.8f;
base.seed = 20260830u;
const CaveScallopSample legacy = sampleCaveScallops(base);
const CaveScallopHistorySample disabled = sampleCaveScallopHistory({base, 0.f});
CHECK_EQ(disabled.erosion, legacy.erosion);
CHECK_EQ(disabled.youngerErosion, 0.f);
const CaveScallopHistorySample staged = sampleCaveScallopHistory({base, 1.f});
CHECK(staged.erosion >= legacy.erosion);
CHECK(staged.youngerCoverage > 0.f);
CHECK(staged.youngerErosion > 0.f);
CHECK(staged.secondaryScaleRatio < 1.f);
CHECK_EQ(staged.erosion, sampleCaveScallopHistory({base, 1.f}).erosion);
float minimumReversal = 1.f;
float maximumReversal = 0.f;
for (int i = 0; i <= 20; ++i) {
base.along = float(i) * 0.08f;
const CaveScallopHistorySample reach = sampleCaveScallopHistory({base, 1.f});
minimumReversal = std::min(minimumReversal, reach.reversalMask);
maximumReversal = std::max(maximumReversal, reach.reversalMask);
}
CHECK(maximumReversal - minimumReversal > 0.35f);
}
TEST_CASE("procgen.mesh.cave.scallopFlowHistoryIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("bedding", 0.f);
params.setFloat("fractureDissolution", 0.f);
params.setFloat("scallopErosion", 1.f);
params.setFloat("scallopFlowSeparation", 0.8f);
MeshBuild omitted, explicitLegacy, staged, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("scallopFlowHistory", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("scallopFlowHistory", 0.85f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, staged, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(staged.positions() != explicitLegacy.positions());
CHECK(staged.positions() == repeated.positions());
CHECK(staged.indices() == repeated.indices());
CHECK_EQ(staged.getMeta("scallopFlowHistoryModel", ""),
std::string("partitioned-base-flood-reversal-overprint-v1"));
CHECK(std::stoi(staged.getMeta("scallopHistoryAffectedVoxels", "0")) > 0);
CHECK(std::stof(staged.getMeta("maximumYoungerScallopErosion", "0")) > 0.f);
CHECK(std::stof(staged.getMeta("minimumSecondaryScallopScaleRatio", "1")) < 1.f);
params.setFloat("scallopFlowHistory", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.secondaryMineralArmoringIsPatchyProtectiveAndHydraulicallyStripped") {
CaveMineralArmoringInput input;
input.passageAlong = 0.31f;
input.passageAngle = 0.72f;
input.hydraulicIntensity = 0.35f;
input.mineralSupply = 1.f;
input.seed = 20260830u;
const CaveMineralArmoringSample sheltered = sampleCaveMineralArmoring(input);
CHECK(sheltered.coatingCoverage > 0.f);
CHECK(sheltered.hydraulicRetention > 0.f);
CHECK(sheltered.dissolutionRetention < 1.f);
CHECK_EQ(sheltered.dissolutionRetention, sampleCaveMineralArmoring(input).dissolutionRetention);
input.hydraulicIntensity = 1.4f;
const CaveMineralArmoringSample flushed = sampleCaveMineralArmoring(input);
CHECK_EQ(flushed.coatingCoverage, sheltered.coatingCoverage);
CHECK(flushed.hydraulicRetention < sheltered.hydraulicRetention);
CHECK(flushed.dissolutionRetention > sheltered.dissolutionRetention);
input.mineralSupply = 0.f;
const CaveMineralArmoringSample absent = sampleCaveMineralArmoring(input);
CHECK_EQ(absent.coatingCoverage, 0.f);
CHECK_EQ(absent.dissolutionRetention, 1.f);
}
TEST_CASE("procgen.mesh.cave.mineralArmoringIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "mixed");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("bedding", 0.7f);
params.setFloat("fractureDissolution", 0.8f);
MeshBuild omitted, explicitLegacy, armored, repeated, noChemicalLegacy, inactive;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("mineralArmoring", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("mineralArmoring", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, armored, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(armored.positions() != explicitLegacy.positions());
CHECK(armored.positions() == repeated.positions());
CHECK(armored.indices() == repeated.indices());
CHECK_EQ(armored.getMeta("mineralArmoringModel", ""),
std::string("genesis-supplied-hydraulic-stripping-shield-v1"));
CHECK(std::stoi(armored.getMeta("mineralArmoringAffectedVoxels", "0")) > 0);
CHECK(std::stof(armored.getMeta("maximumMineralCoatingCoverage", "0")) > 0.f);
CHECK(std::stof(armored.getMeta("minimumArmoredDissolutionRetention", "1")) < 1.f);
params.setFloat("erosion", 0.f);
params.setFloat("mineralArmoring", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noChemicalLegacy, error));
params.setFloat("mineralArmoring", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, inactive, error));
CHECK(noChemicalLegacy.positions() == inactive.positions());
CHECK(noChemicalLegacy.indices() == inactive.indices());
CHECK_EQ(inactive.getMeta("mineralArmoringModel", ""), std::string("inactive-no-chemical-retreat"));
params.setFloat("mineralArmoring", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.breakdownBlocksDriveUpstreamHorseshoeAndDownstreamWakeScour") {
CaveBreakdownSet breakdown;
CaveBreakdownEvent event;
event.blocks.push_back({0.f, -0.15f, 0.f, 0.07f, 0.05f, 0.06f, 0.f});
breakdown.events.push_back(event);
breakdown.blockCount = 1;
const std::vector<CaveHydrologyPoint> trunk{{{-0.5f, 0.f, 0.f}, 0.2f}, {{0.5f, 0.f, 0.f}, 0.2f}};
const std::vector<CaveObstacleScourSite> smooth =
createCaveObstacleScourSites(breakdown, trunk, {1.2f}, 0.48f, 0.f);
const std::vector<CaveObstacleScourSite> rough = createCaveObstacleScourSites(breakdown, trunk, {1.2f}, 0.48f, 1.f);
REQUIRE_EQ(smooth.size(), size_t(1));
REQUIRE_EQ(rough.size(), size_t(1));
CHECK(smooth[0].frontCenter.x < smooth[0].blockCenter.x);
CHECK(smooth[0].wakeCenter.x > smooth[0].blockCenter.x);
CHECK(smooth[0].erosionPotential > rough[0].erosionPotential);
CaveHydrologyVec3 frontLobe = smooth[0].frontCenter;
frontLobe.z += smooth[0].frontLateralRadius * 0.42f;
const CaveObstacleScourSample front = sampleCaveObstacleScour(frontLobe, smooth);
const CaveObstacleScourSample wake = sampleCaveObstacleScour(smooth[0].wakeCenter, smooth);
CHECK(front.horseshoeScour > 0.f);
CHECK(wake.wakeScour > 0.f);
CHECK(front.horseshoeScour > wake.wakeScour);
CHECK_EQ(front.erosion, sampleCaveObstacleScour(frontLobe, smooth).erosion);
CHECK(createCaveObstacleScourSites({}, trunk, {1.2f}, 0.48f, 0.f).empty());
CHECK(createCaveObstacleScourSites(breakdown, trunk, {1.2f}, 0.f, 0.f).empty());
}
TEST_CASE("procgen.mesh.cave.breakdownScourIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 6);
params.setInt("branches", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
params.setFloat("breakdown", 1.f);
params.setInt("breakdownEvents", 5);
params.setFloat("sedimentLoad", 0.48f);
MeshBuild omitted, explicitLegacy, eroded, repeated, hypogeneOff, hypogeneOn, noBlocksOff, noBlocksOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("breakdownScour", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("breakdownScour", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, eroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(eroded.positions() != explicitLegacy.positions());
CHECK(eroded.positions() == repeated.positions());
CHECK(eroded.indices() == repeated.indices());
CHECK_EQ(eroded.getMeta("breakdownScourModel", ""), std::string("roughness-damped-horseshoe-wake-scour-v1"));
CHECK(std::stoi(eroded.getMeta("breakdownScourSites", "0")) > 0);
CHECK(std::stoi(eroded.getMeta("breakdownScourAffectedVoxels", "0")) > 0);
CHECK(std::stof(eroded.getMeta("maximumBreakdownScourRetreat", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumHorseshoeScour", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumWakeScour", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("breakdownScour", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("breakdownScour", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("breakdownScourModel", ""), std::string("inactive-hypogene"));
params.setString("genesis", "epigene");
params.setFloat("breakdown", 0.f);
params.setFloat("breakdownScour", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noBlocksOff, error));
params.setFloat("breakdownScour", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noBlocksOn, error));
CHECK(noBlocksOff.positions() == noBlocksOn.positions());
CHECK(noBlocksOff.indices() == noBlocksOn.indices());
CHECK_EQ(noBlocksOn.getMeta("breakdownScourModel", ""), std::string("inactive-no-breakdown-blocks"));
params.setFloat("breakdownScour", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.eddyPotholesRequireCrossingFracturesAndResolveGravelBias") {
const std::vector<CaveHydrologyPoint> trunk{{{-0.45f, 0.f, 0.f}, 0.2f}, {{0.45f, 0.f, 0.f}, 0.2f}};
const std::vector<float> hydraulic{1.2f};
const std::vector<CaveFracture> fractures{{1.f, 0.f, 0.f, 0.04f}, {0.f, 1.f, 0.f, 0.04f}};
const std::vector<CavePotholeSite> fine =
createCavePotholeSites(trunk, hydraulic, fractures, 0.f, 0.f, 0.48f, 0.f, 20260830u);
const std::vector<CavePotholeSite> coarse =
createCavePotholeSites(trunk, hydraulic, fractures, 0.f, 0.f, 0.48f, 1.f, 20260830u);
REQUIRE_EQ(fine.size(), size_t(1));
REQUIRE_EQ(coarse.size(), size_t(1));
CHECK(fine[0].center.y < 0.f);
CHECK(fine[0].fractureIntersection > 0.f);
CaveHydrologyVec3 downstream = fine[0].center;
downstream.x += fine[0].alongRadius * 0.22f;
const CavePotholeSample fineDownstream = sampleCavePotholeErosion(downstream, fine);
const CavePotholeSample coarseDownstream = sampleCavePotholeErosion(downstream, coarse);
CHECK(fineDownstream.erosion > coarseDownstream.erosion);
CHECK(fineDownstream.downstreamBias > 0.f);
CHECK(coarseDownstream.downstreamBias < 0.f);
CaveHydrologyVec3 deep = fine[0].center;
deep.y -= fine[0].depthRadius * 0.72f;
CHECK(sampleCavePotholeErosion(deep, fine).secondaryPothole > 0.f);
CHECK(createCavePotholeSites(trunk, hydraulic, {fractures[0]}, 0.f, 0.f, 0.48f, 0.5f, 20260830u).empty());
CHECK(createCavePotholeSites(trunk, hydraulic, fractures, 0.f, 0.f, 0.f, 0.5f, 20260830u).empty());
}
TEST_CASE("procgen.mesh.cave.eddyPotholesAreObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 5);
params.setInt("branches", 5);
params.setInt("fractureCount", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
params.setFloat("sedimentLoad", 0.48f);
MeshBuild omitted, explicitLegacy, eroded, repeated, hypogeneOff, hypogeneOn, noToolsOff, noToolsOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("eddyPotholes", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("eddyPotholes", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, eroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(eroded.positions() != explicitLegacy.positions());
CHECK(eroded.positions() == repeated.positions());
CHECK(eroded.indices() == repeated.indices());
CHECK_EQ(eroded.getMeta("eddyPotholeModel", ""), std::string("gravel-size-dependent-compound-eddy-pothole-v1"));
CHECK(std::stoi(eroded.getMeta("eddyPotholeSites", "0")) > 0);
CHECK(std::stoi(eroded.getMeta("eddyPotholeAffectedVoxels", "0")) > 0);
CHECK(std::stof(eroded.getMeta("maximumPotholeRetreat", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumPotholeSecondaryErosion", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumPotholeFractureIntersection", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("eddyPotholes", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("eddyPotholes", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("eddyPotholeModel", ""), std::string("inactive-hypogene"));
params.setString("genesis", "epigene");
params.setFloat("sedimentLoad", 0.f);
params.setFloat("eddyPotholes", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOff, error));
params.setFloat("eddyPotholes", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOn, error));
CHECK(noToolsOff.positions() == noToolsOn.positions());
CHECK(noToolsOff.indices() == noToolsOn.indices());
CHECK_EQ(noToolsOn.getMeta("eddyPotholeModel", ""), std::string("inactive-no-tools"));
params.setFloat("eddyPotholes", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.streamBedKarrenRequiresFloorFlowAndFractures") {
const CaveKarrenSample floor = sampleCaveStreamKarren({3.1415926535f, 1.2f, 0.9f, 0.65f});
const CaveKarrenSample roof = sampleCaveStreamKarren({0.f, 1.2f, 0.9f, 0.65f});
const CaveKarrenSample dry = sampleCaveStreamKarren({3.1415926535f, 0.2f, 0.9f, 0.65f});
const CaveKarrenSample oneSet = sampleCaveStreamKarren({3.1415926535f, 1.2f, 0.9f, 0.f});
const CaveKarrenSample crossing = sampleCaveStreamKarren({3.1415926535f, 1.2f, 0.9f, 0.9f});
CHECK(floor.erosion > 0.f);
CHECK(floor.floorExposure > 0.99f);
CHECK(roof.erosion == 0.f);
CHECK(dry.erosion == 0.f);
CHECK(crossing.erosion > oneSet.erosion);
CHECK(crossing.intersectionPocket > 0.f);
CHECK_EQ(floor.erosion, sampleCaveStreamKarren({3.1415926535f, 1.2f, 0.9f, 0.65f}).erosion);
}
TEST_CASE("procgen.mesh.cave.streamBedKarrenIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 5);
params.setInt("branches", 5);
params.setInt("fractureCount", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, eroded, repeated, hypogeneOff, hypogeneOn, noFracturesOff, noFracturesOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("streamBedKarren", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("streamBedKarren", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, eroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(eroded.positions() != explicitLegacy.positions());
CHECK(eroded.positions() == repeated.positions());
CHECK(eroded.indices() == repeated.indices());
CHECK_EQ(eroded.getMeta("streamBedKarrenModel", ""),
std::string("lidar-constrained-fracture-guided-bed-karren-v1"));
CHECK(std::stoi(eroded.getMeta("streamBedKarrenAffectedVoxels", "0")) > 0);
CHECK(std::stof(eroded.getMeta("maximumStreamBedKarrenRetreat", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumKarrenFractureGuidance", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumKarrenIntersectionPocket", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("streamBedKarren", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("streamBedKarren", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("streamBedKarrenModel", ""), std::string("inactive-hypogene"));
params.setString("genesis", "epigene");
params.setInt("fractureCount", 1);
params.setFloat("streamBedKarren", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noFracturesOff, error));
params.setFloat("streamBedKarren", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noFracturesOn, error));
CHECK(noFracturesOff.positions() == noFracturesOn.positions());
CHECK(noFracturesOff.indices() == noFracturesOn.indices());
CHECK_EQ(noFracturesOn.getMeta("streamBedKarrenModel", ""), std::string("inactive-no-crossing-fractures"));
params.setFloat("streamBedKarren", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.knickpointsFollowDownstreamSlopeBreaks") {
const std::vector<CaveHydrologyPoint> trunk{{{-0.8f, 0.10f, 0.f}, 0.2f},
{{-0.4f, 0.08f, 0.f}, 0.2f},
{{0.f, 0.06f, 0.f}, 0.2f},
{{0.4f, -0.20f, 0.f}, 0.2f},
{{0.8f, -0.22f, 0.f}, 0.2f}};
const std::vector<float> hydraulic{0.5f, 0.7f, 1.1f, 1.2f, 1.2f};
const std::vector<CaveKnickpointSite> sites = createCaveKnickpointSites(trunk, hydraulic, 0.48f);
REQUIRE_EQ(sites.size(), size_t(1));
CHECK(sites[0].poolCenter.x > sites[0].lip.x);
CHECK(sites[0].poolCenter.y < sites[0].lip.y);
CHECK(sites[0].slopeBreak > 0.4f);
CHECK(sites[0].drop > 0.2f);
const CaveKnickpointSample pool = sampleCaveKnickpointErosion(sites[0].poolCenter, sites);
const CaveKnickpointSample repeated = sampleCaveKnickpointErosion(sites[0].poolCenter, sites);
const CaveKnickpointSample far = sampleCaveKnickpointErosion({0.9f, 0.9f, 0.9f}, sites);
CHECK_EQ(pool.erosion, repeated.erosion);
CHECK(pool.verticalDrilling > pool.headwallUndercut);
CHECK(pool.erosion > far.erosion);
CHECK(createCaveKnickpointSites(trunk, hydraulic, 0.f).empty());
std::vector<CaveHydrologyPoint> mild = trunk;
for (size_t i = 0; i < mild.size(); ++i) mild[i].position.y = 0.1f - float(i) * 0.02f;
CHECK(createCaveKnickpointSites(mild, hydraulic, 0.48f).empty());
CHECK(createCaveKnickpointSites(trunk, hydraulic, 0.48f)[0].erosionPotential >
createCaveKnickpointSites(trunk, hydraulic, 1.f)[0].erosionPotential);
}
TEST_CASE("procgen.mesh.cave.knickpointErosionIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 5);
params.setInt("branches", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
params.setFloat("sedimentLoad", 0.48f);
MeshBuild omitted, explicitLegacy, eroded, repeated, hypogeneOff, hypogeneOn, noToolsOff, noToolsOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("knickpointErosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("knickpointErosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, eroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(eroded.positions() != explicitLegacy.positions());
CHECK(eroded.positions() == repeated.positions());
CHECK(eroded.indices() == repeated.indices());
CHECK_EQ(eroded.getMeta("knickpointErosionModel", ""), std::string("sediment-driven-headward-plunge-pool-v1"));
CHECK(std::stoi(eroded.getMeta("knickpointSites", "0")) > 0);
CHECK(std::stoi(eroded.getMeta("knickpointAffectedVoxels", "0")) > 0);
CHECK(std::stof(eroded.getMeta("maximumKnickpointRetreat", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumKnickpointSlopeBreak", "0")) > 0.f);
CHECK(std::stof(eroded.getMeta("maximumKnickpointDrop", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("knickpointErosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("knickpointErosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("knickpointErosionModel", ""), std::string("inactive-hypogene"));
params.setString("genesis", "epigene");
params.setFloat("sedimentLoad", 0.f);
params.setFloat("knickpointErosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOff, error));
params.setFloat("knickpointErosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOn, error));
CHECK(noToolsOff.positions() == noToolsOn.positions());
CHECK(noToolsOff.indices() == noToolsOn.indices());
CHECK_EQ(noToolsOn.getMeta("knickpointErosionModel", ""), std::string("inactive-no-tools"));
params.setFloat("knickpointErosion", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.constrictionScourFollowsRadiusMinimumDownstream") {
const std::vector<CaveHydrologyPoint> trunk{{{-0.8f, 0.10f, 0.f}, 0.22f},
{{-0.4f, 0.06f, 0.f}, 0.21f},
{{0.f, 0.f, 0.f}, 0.11f},
{{0.4f, -0.04f, 0.f}, 0.22f},
{{0.8f, -0.08f, 0.f}, 0.24f}};
CaveHydrologyWeights hydrology;
hydrology.trunk = {0.7f, 0.8f, 1.1f, 1.2f, 1.25f};
const std::vector<CaveConstrictionScourSite> sites = createCaveConstrictionScourSites(trunk, {}, hydrology);
REQUIRE_EQ(sites.size(), size_t(1));
CHECK(sites[0].poolCenter.x > sites[0].constriction.x);
CHECK(sites[0].poolCenter.y < sites[0].constriction.y);
CHECK(sites[0].constrictionRatio > 0.4f);
const CaveConstrictionScourSample pool = sampleCaveConstrictionScour(sites[0].poolCenter, sites);
const CaveConstrictionScourSample repeated = sampleCaveConstrictionScour(sites[0].poolCenter, sites);
const CaveConstrictionScourSample far = sampleCaveConstrictionScour({0.9f, 0.9f, 0.9f}, sites);
CHECK_EQ(pool.erosion, repeated.erosion);
CHECK(pool.bedScour > 0.f);
CHECK(pool.erosion > far.erosion);
std::vector<CaveHydrologyPoint> uniform = trunk;
for (CaveHydrologyPoint& point : uniform) point.radius = 0.2f;
CHECK(createCaveConstrictionScourSites(uniform, {}, hydrology).empty());
}
TEST_CASE("procgen.mesh.cave.plungingEfficiencyHasDischargeDependentOptimum") {
auto makeSite = [&](float ratio, float hydraulicIntensity) {
const float shoulderRadius = 0.2f;
const std::vector<CaveHydrologyPoint> path{{{-0.8f, 0.f, 0.f}, shoulderRadius},
{{-0.4f, 0.f, 0.f}, shoulderRadius},
{{0.f, 0.f, 0.f}, shoulderRadius * (1.f - ratio)},
{{0.4f, 0.f, 0.f}, shoulderRadius},
{{0.8f, 0.f, 0.f}, shoulderRadius}};
CaveHydrologyWeights hydrology;
hydrology.trunk = {hydraulicIntensity, hydraulicIntensity, hydraulicIntensity, hydraulicIntensity,
hydraulicIntensity};
const std::vector<CaveConstrictionScourSite> sites = createCaveConstrictionScourSites(path, {}, hydrology);
REQUIRE_EQ(sites.size(), size_t(1));
return sites.front();
};
const CaveConstrictionScourSite lowOptimal = makeSite(0.35f, 0.25f);
const CaveConstrictionScourSite lowOverConstricted = makeSite(0.75f, 0.25f);
CHECK(lowOptimal.plungingEfficiency > lowOverConstricted.plungingEfficiency * 4.f);
CHECK(std::fabs(lowOptimal.optimalConstriction - 0.35f) < 1e-5f);
const CaveConstrictionScourSite highAtFifty = makeSite(0.50f, 1.6f);
const CaveConstrictionScourSite highAtThirtyFive = makeSite(0.35f, 1.6f);
CHECK(highAtFifty.plungingEfficiency > highAtThirtyFive.plungingEfficiency);
CHECK(std::fabs(highAtFifty.optimalConstriction - 0.50f) < 1e-5f);
}
TEST_CASE("procgen.mesh.cave.constrictionScourIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 5);
params.setInt("branches", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, scoured, repeated, hypogeneOff, hypogeneOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("constrictionScour", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("constrictionScour", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, scoured, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(scoured.positions() != explicitLegacy.positions());
CHECK(scoured.positions() == repeated.positions());
CHECK(scoured.indices() == repeated.indices());
CHECK_EQ(scoured.getMeta("constrictionScourModel", ""), std::string("discharge-optimal-plunging-flow-cpw-v2"));
CHECK(std::stoi(scoured.getMeta("constrictionScourSites", "0")) > 0);
CHECK(std::stoi(scoured.getMeta("constrictionScourAffectedVoxels", "0")) > 0);
CHECK(std::stof(scoured.getMeta("maximumConstrictionScourRetreat", "0")) > 0.f);
CHECK(std::stof(scoured.getMeta("maximumConstrictionRatio", "0")) > 0.f);
CHECK(std::stof(scoured.getMeta("maximumPlungingEfficiency", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("constrictionScour", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("constrictionScour", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("constrictionScourModel", ""), std::string("inactive-hypogene"));
params.setFloat("constrictionScour", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.floodPluckingRequiresFracturesFlowAndSelectedBlocks") {
CavePluckingInput input{0.035f, -0.012f, 0.041f, 3.1415926535f, 1.2f, 1.f, 0.85f, 0.11f, 20260830u};
CavePluckingSample selected;
for (int z = -12; z <= 12 && selected.blockMask <= 0.1f; ++z) {
for (int x = -12; x <= 12 && selected.blockMask <= 0.1f; ++x) {
input.x = float(x) * 0.025f;
input.z = float(z) * 0.025f;
const CavePluckingSample candidate = sampleCaveFloodPlucking(input);
if (candidate.blockMask > selected.blockMask) selected = candidate;
}
}
REQUIRE(selected.blockMask > 0.1f);
CHECK(selected.erosion > 0.f);
CHECK(selected.fracturePredisposition > 0.f);
CHECK(selected.hydraulicActivation > 0.f);
const CavePluckingSample repeated = sampleCaveFloodPlucking(input);
CHECK_EQ(repeated.erosion, sampleCaveFloodPlucking(input).erosion);
CavePluckingInput unfractured = input;
unfractured.primaryFractureMask = 0.f;
unfractured.secondaryFractureMask = 0.f;
CHECK_EQ(sampleCaveFloodPlucking(unfractured).erosion, 0.f);
CavePluckingInput lowFlow = input;
lowFlow.hydraulicIntensity = 0.1f;
CHECK_EQ(sampleCaveFloodPlucking(lowFlow).erosion, 0.f);
}
TEST_CASE("procgen.mesh.cave.floodPluckingIsBlockyObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 36);
params.setInt("chambers", 5);
params.setInt("branches", 4);
params.setInt("fractureCount", 10);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, plucked, repeated, noFracturesOff, noFracturesOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("floodPlucking", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("floodPlucking", 1.f);
params.setFloat("pluckingBlockScale", 0.14f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, plucked, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(plucked.positions() != explicitLegacy.positions());
CHECK(plucked.positions() == repeated.positions());
CHECK(plucked.indices() == repeated.indices());
CHECK_EQ(plucked.getMeta("floodPluckingModel", ""), std::string("thresholded-fracture-block-release-v1"));
CHECK(std::stoi(plucked.getMeta("pluckingAffectedVoxels", "0")) > 0);
CHECK(std::stof(plucked.getMeta("maximumPluckingRetreat", "0")) > 0.f);
CHECK(std::stof(plucked.getMeta("maximumPluckingPredisposition", "0")) > 0.f);
params.setInt("fractureCount", 0);
params.setFloat("floodPlucking", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noFracturesOff, error));
params.setFloat("floodPlucking", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noFracturesOn, error));
CHECK(noFracturesOff.positions() == noFracturesOn.positions());
CHECK(noFracturesOff.indices() == noFracturesOn.indices());
CHECK_EQ(noFracturesOn.getMeta("floodPluckingModel", ""), std::string("inactive-no-fracture-network"));
params.setFloat("floodPlucking", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.floodAbrasionIsNearBedFlowDrivenAndToolsLimited") {
const CaveAbrasionInput floorInput{0.42f, 3.1415926535f, 1.f, 0.45f, 3.1415926535f, 0.48f, 20260830u};
const CaveAbrasionSample floor = sampleCaveFloodAbrasion(floorInput);
const CaveAbrasionSample repeated = sampleCaveFloodAbrasion(floorInput);
CHECK_EQ(floor.erosion, repeated.erosion);
CHECK(floor.floorMask > 0.99f);
CHECK(floor.erosion > 0.f);
CHECK(floor.coverProtection > 0.f);
CaveAbrasionInput crownInput = floorInput;
crownInput.angle = 0.f;
const CaveAbrasionSample crown = sampleCaveFloodAbrasion(crownInput);
CHECK(crown.erosion < floor.erosion * 0.01f);
CaveAbrasionInput lowFlowInput = floorInput;
lowFlowInput.hydraulicIntensity = 0.15f;
CHECK(sampleCaveFloodAbrasion(lowFlowInput).erosion < floor.erosion);
CaveAbrasionInput noToolsInput = floorInput;
noToolsInput.sedimentLoad = 0.f;
const CaveAbrasionSample noTools = sampleCaveFloodAbrasion(noToolsInput);
CHECK_EQ(noTools.erosion, 0.f);
CHECK_EQ(noTools.toolAvailability, 0.f);
}
TEST_CASE("procgen.mesh.cave.floodAbrasionIsObservableBoundedAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setString("genesis", "epigene");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 4);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, abraded, repeated, noToolsOff, noToolsOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("floodAbrasion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("floodAbrasion", 1.f);
params.setFloat("sedimentLoad", 0.48f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, abraded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(abraded.positions() != explicitLegacy.positions());
CHECK(abraded.positions() == repeated.positions());
CHECK(abraded.indices() == repeated.indices());
CHECK_EQ(abraded.getMeta("floodAbrasionModel", ""), std::string("near-bed-tools-cover-vortex-v1"));
CHECK(std::stoi(abraded.getMeta("abrasionAffectedVoxels", "0")) > 0);
CHECK(std::stof(abraded.getMeta("maximumAbrasionRetreat", "0")) > 0.f);
CHECK(std::stof(abraded.getMeta("maximumAbrasionVortex", "0")) > 0.f);
params.setFloat("sedimentLoad", 0.f);
params.setFloat("floodAbrasion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOff, error));
params.setFloat("floodAbrasion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noToolsOn, error));
CHECK(noToolsOff.positions() == noToolsOn.positions());
CHECK(noToolsOff.indices() == noToolsOn.indices());
CHECK_EQ(noToolsOn.getMeta("floodAbrasionModel", ""), std::string("inactive-no-tools"));
params.setFloat("floodAbrasion", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.lithologyFormsBedCoherentFlowAccessibleStyloliteRetreat") {
CaveLithologyInput input{0.12f, -1.f, -0.18f, 0.42f, 1.f, 1.f, 20260830u};
CaveLithologySample sample;
for (int step = 0; step <= 400; ++step) {
input.y = -1.f + float(step) / 200.f;
const CaveLithologySample candidate = sampleCaveLithology(input);
if (candidate.styloliteMask > sample.styloliteMask) sample = candidate;
}
REQUIRE(sample.styloliteMask > 0.2f);
input.y = (float(sample.bedIndex) / 7.25f) -
(std::sin(input.x * 2.1f + input.z * 1.7f + float(input.seed % 4093u) * 0.001534326f) * 0.035f +
std::sin(input.x * 4.7f - input.z * 3.2f + float(input.seed % 4093u) * 0.001534326f * 1.61f) * 0.012f);
const CaveLithologySample repeated = sampleCaveLithology(input);
const CaveLithologySample repeatedAgain = sampleCaveLithology(input);
CHECK_EQ(repeated.bedIndex, repeatedAgain.bedIndex);
CHECK_EQ(repeated.styloliteMask, repeatedAgain.styloliteMask);
CHECK(repeated.bedResistance >= 0.65f);
CHECK(repeated.bedResistance <= 1.35f);
CaveLithologyInput stagnantInput = input;
stagnantInput.hydraulicIntensity = 0.f;
const CaveLithologySample stagnant = sampleCaveLithology(stagnantInput);
CHECK(repeated.retreat > stagnant.retreat);
CaveLithologyInput disabledInput = input;
disabledInput.heterogeneity = 0.f;
const CaveLithologySample disabled = sampleCaveLithology(disabledInput);
CHECK_EQ(disabled.retreat, 0.f);
CHECK_EQ(disabled.styloliteMask, 0.f);
CHECK_EQ(disabled.bedResistance, 1.f);
}
TEST_CASE("procgen.mesh.cave.lithologicHeterogeneityIsSelectiveObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 4);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, selective, repeated, noBeddingOff, noBeddingOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("lithologicHeterogeneity", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("lithologicHeterogeneity", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, selective, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(selective.positions() != explicitLegacy.positions());
CHECK(selective.positions() == repeated.positions());
CHECK(selective.indices() == repeated.indices());
CHECK_EQ(selective.getMeta("lithologyErosionModel", ""), std::string("flow-accessible-stylolite-beds-v1"));
CHECK(std::stoi(selective.getMeta("lithologyAffectedVoxels", "0")) > 0);
CHECK(std::stoi(selective.getMeta("styloliteAffectedVoxels", "0")) > 0);
CHECK(std::stof(selective.getMeta("minimumBedResistance", "1")) < 1.f);
CHECK(std::stof(selective.getMeta("maximumLithologyRetreat", "0")) > 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("lithologicHeterogeneity", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noBeddingOff, error));
params.setFloat("lithologicHeterogeneity", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noBeddingOn, error));
CHECK(noBeddingOff.positions() == noBeddingOn.positions());
CHECK(noBeddingOff.indices() == noBeddingOn.indices());
CHECK_EQ(noBeddingOn.getMeta("lithologyErosionModel", ""), std::string("disabled"));
params.setFloat("lithologicHeterogeneity", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.mixingSitesReuseConfluencesAndCarveLocally") {
const std::vector<CaveHydrologyPoint> trunk{
{{-0.5f, 0.f, 0.f}, 0.20f}, {{0.f, 0.f, 0.f}, 0.22f}, {{0.5f, 0.f, 0.f}, 0.21f}};
CaveHydrologyBranch branch;
branch.trunkAnchor = 1;
branch.points = {{{0.f, 0.f, 0.f}, 0.22f}, {{0.f, 0.f, 0.35f}, 0.18f}};
const std::vector<CaveMixingSite> sites = createCaveMixingSites(trunk, {branch}, 20260830u);
const std::vector<CaveMixingSite> repeatedSites = createCaveMixingSites(trunk, {branch}, 20260830u);
REQUIRE_EQ(sites.size(), size_t(1));
CHECK_EQ(sites[0].mixingPotential, repeatedSites[0].mixingPotential);
CHECK(sites[0].mixingPotential > 0.f);
CHECK(sites[0].mixingPotential <= 1.f);
const CaveMixingCorrosionSample centre = sampleCaveMixingCorrosion({0.f, 0.f, 0.f}, sites);
const CaveMixingCorrosionSample far = sampleCaveMixingCorrosion({0.8f, 0.8f, 0.8f}, sites);
CHECK_EQ(centre.siteIndex, 0);
CHECK(centre.erosion > far.erosion);
CHECK_EQ(far.siteIndex, -1);
}
TEST_CASE("procgen.mesh.cave.mixingCorrosionIsConfluenceBoundedObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 5);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, mixed, repeated, noConfluenceOff, noConfluenceOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("mixingCorrosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("mixingCorrosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, mixed, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(mixed.positions() != explicitLegacy.positions());
CHECK(mixed.positions() == repeated.positions());
CHECK(mixed.indices() == repeated.indices());
CHECK_EQ(mixed.getMeta("mixingCorrosionModel", ""), std::string("chemistry-weighted-confluence-v1"));
CHECK_EQ(mixed.getMeta("mixingCorrosionSites", ""), std::string("5"));
CHECK(std::stoi(mixed.getMeta("mixingCorrosionAffectedVoxels", "0")) > 0);
CHECK(std::stof(mixed.getMeta("maximumMixingCorrosionRetreat", "0")) > 0.f);
params.setInt("branches", 0);
params.setFloat("mixingCorrosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noConfluenceOff, error));
params.setFloat("mixingCorrosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noConfluenceOn, error));
CHECK(noConfluenceOff.positions() == noConfluenceOn.positions());
CHECK(noConfluenceOff.indices() == noConfluenceOn.indices());
CHECK_EQ(noConfluenceOn.getMeta("mixingCorrosionModel", ""), std::string("inactive-no-confluence"));
params.setFloat("mixingCorrosion", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.waterTableBeltsAreLevelSidewallBiasedAndStaged") {
CaveWaterTableInput input;
input.y = 0.30f;
input.passageAngle = 1.57079632679f;
input.along = 0.4f;
input.level = 0.30f;
input.stageDrop = 0.20f;
input.fluctuation = 0.f;
input.stages = 3;
input.seed = 20260830u;
const CaveWaterTableSample upper = sampleCaveWaterTableCorrosion(input);
const CaveWaterTableSample repeated = sampleCaveWaterTableCorrosion(input);
CHECK_EQ(upper.erosion, repeated.erosion);
CHECK_EQ(upper.dominantStage, 0);
CHECK(upper.erosion > 0.99f);
input.y = 0.10f;
const CaveWaterTableSample middle = sampleCaveWaterTableCorrosion(input);
CHECK_EQ(middle.dominantStage, 1);
CHECK(middle.erosion > 0.70f);
CHECK(middle.erosion < upper.erosion);
input.y = 0.30f;
input.passageAngle = 0.f;
const CaveWaterTableSample crown = sampleCaveWaterTableCorrosion(input);
CHECK(crown.erosion < upper.erosion * 0.01f);
}
TEST_CASE("procgen.mesh.cave.waterTableCorrosionIsEpiphreaticObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "cavern");
params.setString("genesis", "epigene");
params.setInt("resolution", 34);
params.setInt("chambers", 6);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, corroded, repeated, hypogeneOff, hypogeneOn;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("waterTableCorrosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("waterTableCorrosion", 1.f);
params.setFloat("waterTableLevel", 0.3f);
params.setInt("waterTableStages", 3);
params.setFloat("waterTableDrop", 0.2f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, corroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(corroded.positions() != explicitLegacy.positions());
CHECK(corroded.positions() == repeated.positions());
CHECK(corroded.indices() == repeated.indices());
CHECK_EQ(corroded.getMeta("waterTableCorrosionModel", ""), std::string("descending-epiphreatic-belts-v1"));
CHECK(std::stoi(corroded.getMeta("waterTableAffectedVoxels", "0")) > 0);
CHECK(std::stof(corroded.getMeta("maximumWaterTableRetreat", "0")) > 0.f);
params.setString("genesis", "hypogene");
params.setFloat("waterTableCorrosion", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOff, error));
params.setFloat("waterTableCorrosion", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneOn, error));
CHECK(hypogeneOff.positions() == hypogeneOn.positions());
CHECK(hypogeneOff.indices() == hypogeneOn.indices());
CHECK_EQ(hypogeneOn.getMeta("waterTableCorrosionModel", ""), std::string("inactive-hypogene"));
params.setFloat("waterTableCorrosion", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.multiscaleWallReliefIsBoundedAndDeterministic") {
const CaveRoughnessSample first = sampleCaveWallRoughness({0.17f, -0.23f, 0.41f, 20260830u});
const CaveRoughnessSample repeat = sampleCaveWallRoughness({0.17f, -0.23f, 0.41f, 20260830u});
const CaveRoughnessSample shifted = sampleCaveWallRoughness({0.19f, -0.23f, 0.41f, 20260830u});
const CaveRoughnessSample reseeded = sampleCaveWallRoughness({0.17f, -0.23f, 0.41f, 20260831u});
CHECK_EQ(first.relief, repeat.relief);
CHECK(first.relief >= -1.f);
CHECK(first.relief <= 1.f);
CHECK(first.relief != shifted.relief);
CHECK(first.relief != reseeded.relief);
CHECK(first.macroBand != first.mesoBand);
CHECK(first.mesoBand != first.fineBand);
}
TEST_CASE("procgen.mesh.cave.multiscaleRoughnessIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.28f);
params.setFloat("erosion", 0.f);
params.setFloat("vadoseIncision", 0.f);
MeshBuild omitted, explicitLegacy, spectral, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("multiscaleRoughness", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("multiscaleRoughness", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, spectral, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(spectral.positions() != explicitLegacy.positions());
CHECK(spectral.positions() == repeated.positions());
CHECK(spectral.indices() == repeated.indices());
CHECK_EQ(spectral.getMeta("wallRoughnessSpectrum", ""), std::string("band-limited-three-scale-v1"));
CHECK(std::stof(spectral.getMeta("minimumWallRelief", "0")) < 0.f);
CHECK(std::stof(spectral.getMeta("maximumWallRelief", "0")) > 0.f);
params.setFloat("multiscaleRoughness", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.fractureApertureAndStressSplittingAreDeterministicOptIns") {
CaveFractureInput input;
input.x = 0.03f;
input.y = 0.17f;
input.z = -0.04f;
input.fracture = {0.8f, 0.6f, 0.01f, 0.025f};
input.seed = 20260830u;
const CaveFractureSample legacy = sampleCaveFracture(input);
CHECK_EQ(legacy.apertureMultiplier, 1.f);
CHECK_EQ(legacy.branchOpenness, 1.f);
input.apertureVariability = 0.8f;
const CaveFractureSample heterogeneous = sampleCaveFracture(input);
const CaveFractureSample repeated = sampleCaveFracture(input);
CHECK(heterogeneous.apertureMultiplier != 1.f);
CHECK_EQ(heterogeneous.mask, repeated.mask);
CHECK_EQ(heterogeneous.apertureMultiplier, repeated.apertureMultiplier);
input.stressControl = 0.9f;
const CaveFractureSample stressed = sampleCaveFracture(input);
CHECK(stressed.branchOpenness < 1.f);
CHECK(stressed.mask != heterogeneous.mask);
}
TEST_CASE("procgen.mesh.cave.fractureChannelizationFollowsCubicApertureIntersectionsAndReactantAccess") {
CaveFractureChannelizationInput input;
input.primaryMask = 0.9f;
input.primaryApertureMultiplier = 1.55f;
input.hydraulicIntensity = 1.2f;
input.distanceFromInlet = 0.15f;
input.reactantPenetration = 0.8f;
const CaveFractureChannelizationSample isolated = sampleCaveFractureChannelization(input);
CHECK(isolated.erosion > 0.f);
CHECK(isolated.flowConcentration > 0.f);
CHECK_EQ(isolated.intersectionAmplification, 0.f);
CHECK_EQ(isolated.erosion, sampleCaveFractureChannelization(input).erosion);
input.secondaryMask = 0.8f;
input.secondaryApertureMultiplier = 1.45f;
const CaveFractureChannelizationSample intersection = sampleCaveFractureChannelization(input);
CHECK(intersection.intersectionAmplification > 0.f);
CHECK(intersection.erosion > isolated.erosion);
input.distanceFromInlet = 1.f;
CHECK(sampleCaveFractureChannelization(input).reactantAccess < intersection.reactantAccess);
input.primaryApertureMultiplier = 1.f;
CHECK_EQ(sampleCaveFractureChannelization(input).erosion, 0.f);
}
TEST_CASE("procgen.mesh.cave.fractureFlowFeedbackIsObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("fractureDissolution", 1.f);
params.setFloat("fractureApertureVariability", 0.9f);
params.setInt("fractureCount", 10);
MeshBuild omitted, explicitLegacy, channelized, repeated, inactive;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("fractureFlowFeedback", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("fractureFlowFeedback", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, channelized, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(channelized.positions() != explicitLegacy.positions());
CHECK(channelized.positions() == repeated.positions());
CHECK(channelized.indices() == repeated.indices());
CHECK_EQ(channelized.getMeta("fractureFlowFeedbackModel", ""),
std::string("cubic-aperture-reactive-channelization-v1"));
CHECK(std::stoi(channelized.getMeta("fractureChannelAffectedVoxels", "0")) > 0);
CHECK(std::stof(channelized.getMeta("maximumFractureChannelRetreat", "0")) > 0.f);
CHECK(std::stof(channelized.getMeta("maximumFractureFlowConcentration", "0")) > 0.f);
params.setFloat("fractureApertureVariability", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, inactive, error));
CHECK_EQ(inactive.getMeta("fractureFlowFeedbackModel", ""), std::string("inactive-no-aperture-contrast"));
params.setFloat("fractureFlowFeedback", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.stressControlledFracturesAreObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("chambers", 5);
params.setInt("branches", 3);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("fractureDissolution", 1.f);
params.setInt("fractureCount", 9);
MeshBuild omitted, explicitLegacy, heterogeneous, stressed, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, omitted, error));
params.setFloat("fractureApertureVariability", 0.f);
params.setFloat("fractureStressControl", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(omitted.positions() == explicitLegacy.positions());
CHECK(omitted.indices() == explicitLegacy.indices());
params.setFloat("fractureApertureVariability", 0.85f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, heterogeneous, error));
params.setFloat("fractureStressControl", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, stressed, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(heterogeneous.positions() != explicitLegacy.positions());
CHECK(stressed.positions() != heterogeneous.positions());
CHECK(stressed.positions() == repeated.positions());
CHECK(stressed.indices() == repeated.indices());
CHECK_EQ(stressed.getMeta("fractureApertureDistribution", ""), std::string("correlated-lognormal-proxy-v1"));
CHECK_EQ(stressed.getMeta("fractureDissolutionFront", ""), std::string("stress-split-branching-v1"));
CHECK(std::stof(stressed.getMeta("fractureApertureGeometricStdDev", "1")) > 1.f);
CHECK(std::stof(stressed.getMeta("minimumFractureApertureMultiplier", "1")) < 1.f);
CHECK(std::stof(stressed.getMeta("maximumFractureApertureMultiplier", "1")) > 1.f);
CHECK(std::stof(stressed.getMeta("minimumFractureBranchOpenness", "1")) < 1.f);
params.setFloat("fractureStressControl", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
}
TEST_CASE("procgen.mesh.cave.sedimentBarsFollowFlowAndClastsImbricateDeterministically") {
const std::vector<CaveSedimentPathPoint> path{{-0.5f, 0.f, 0.f, 0.18f}, {0.5f, 0.f, 0.f, 0.18f}};
const auto first = createCaveSediment(path, 3, 0.8f, 0.f, 20260830u);
const auto repeat = createCaveSediment(path, 3, 0.8f, 0.f, 20260830u);
REQUIRE_EQ(first.bars.size(), size_t(3));
CHECK_EQ(first.clastCount, repeat.clastCount);
CHECK_EQ(first.depositedVolume, repeat.depositedVolume);
CHECK_EQ(first.meanImbricationDegrees, repeat.meanImbricationDegrees);
CHECK(first.clastCount >= 9);
CHECK(first.depositedVolume > 0.f);
CHECK(first.meanImbricationDegrees >= 17.f);
CHECK(first.meanImbricationDegrees <= 28.1f);
CHECK(std::fabs(first.bars[0].flowX) > 0.99f);
CHECK(std::fabs(first.bars[0].flowZ) < 0.01f);
CHECK(first.bars[0].clasts[0].pitch < 0.f);
const auto& bar = first.bars[0];
CHECK(addCaveSediment(bar.x, bar.y, bar.z, -1.f, first) > 0.f);
CHECK(isCaveSedimentSurface(bar.x + bar.flowX * bar.length, bar.y, bar.z + bar.flowZ * bar.length, 0.002f, first));
CHECK(createCaveSediment(path, 3, 0.f, 0.f, 20260830u).bars.empty());
}
TEST_CASE("procgen.mesh.cave.paragenesisRequiresSedimentAndCarvesCeilingAlongPaleoflow") {
const std::vector<CaveSedimentPathPoint> path{{-0.5f, 0.f, 0.f, 0.18f}, {0.5f, 0.f, 0.f, 0.18f}};
const auto present = createCaveSediment(path, 3, 0.8f, 0.75f, 20260830u);
REQUIRE_EQ(present.parageneticChannels, 3);
CHECK(present.maximumCeilingLift > 0.f);
CHECK(present.meanParageneticWidth > 0.f);
const auto& bar = present.bars[0];
CHECK(bar.channelHalfLength > bar.length);
CHECK(carveCaveParagenesis(bar.x, bar.ceilingY, bar.z, 1.f, present) < 0.f);
CHECK(carveCaveParagenesis(bar.x + bar.flowX * bar.channelHalfLength, bar.ceilingY,
bar.z + bar.flowZ * bar.channelHalfLength, 1.f, present) < 0.f);
CHECK(carveCaveParagenesis(bar.x - bar.flowZ * bar.notchHalfWidth * 0.9f, bar.palaeofillY,
bar.z + bar.flowX * bar.notchHalfWidth * 0.9f, 1.f, present) < 0.f);
CHECK(present.meanPalaeofillRatio > 0.6f);
CHECK(present.maximumNotchRetreat > 0.f);
CHECK(present.meanNotchThickness > 0.f);
CHECK(bar.notchHalfHeight > bar.passageRadius * 0.1f * present.paragenesisStrength);
const auto lowSupply = createCaveSediment(path, 3, 0.2f, 0.75f, 20260830u);
const auto highSupply = createCaveSediment(path, 3, 0.9f, 0.75f, 20260830u);
CHECK(lowSupply.meanParageneticWidth > highSupply.meanParageneticWidth);
CHECK(lowSupply.maximumCeilingLift < highSupply.maximumCeilingLift);
CHECK(lowSupply.meanPalaeofillRatio < highSupply.meanPalaeofillRatio);
const auto absent = createCaveSediment(path, 3, 0.f, 0.75f, 20260830u);
CHECK(absent.bars.empty());
CHECK_EQ(absent.parageneticChannels, 0);
CHECK_EQ(carveCaveParagenesis(0.f, 0.15f, 0.f, 0.25f, absent), 0.25f);
}
TEST_CASE("procgen.mesh.cave.sedimentDepositionIsOptInGroupedAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 30);
params.setInt("chambers", 4);
params.setInt("branches", 2);
MeshBuild baseline, first, repeat;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
CHECK_EQ(baseline.getMeta("sedimentModel", ""), std::string("disabled"));
params.setFloat("sedimentDeposition", 0.9f);
params.setInt("sedimentBars", 4);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeat, error));
CHECK(first.positions() == repeat.positions());
CHECK(first.indices() == repeat.indices());
CHECK(first.positions() != baseline.positions());
CHECK_EQ(first.getMeta("sedimentModel", ""), std::string("longitudinal-bar-imbrication-v1"));
CHECK_EQ(std::stoi(first.getMeta("sedimentBars", "0")), 4);
CHECK(std::stoi(first.getMeta("sedimentClasts", "0")) >= 12);
CHECK(std::stof(first.getMeta("sedimentVolume", "0")) > 0.f);
CHECK(std::stof(first.getMeta("meanImbricationDegrees", "0")) > 0.f);
int sedimentGroup = -1;
for (int group = 0; group < first.getGroupCount(); ++group)
if (first.getGroupName(group) == "sediment") sedimentGroup = group;
REQUIRE(sedimentGroup >= 0);
const bool hasSedimentGeometry = first.copyGroup(sedimentGroup) != nullptr;
CHECK(hasSedimentGeometry);
params.setFloat("sedimentDeposition", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.paragenesisIsSedimentDependentOptInAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 30);
params.setInt("chambers", 4);
MeshBuild baseline, noProvider, sedimentOnly, coupled;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("paragenesis", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, noProvider, error));
CHECK(noProvider.positions() == baseline.positions());
CHECK_EQ(noProvider.getMeta("paragenesisStatus", ""), std::string("inactive-no-sediment"));
CHECK_EQ(std::stoi(noProvider.getMeta("parageneticChannels", "-1")), 0);
params.setFloat("paragenesis", 0.f);
params.setFloat("sedimentDeposition", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, sedimentOnly, error));
params.setFloat("paragenesis", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, coupled, error));
CHECK(coupled.positions() != sedimentOnly.positions());
CHECK_EQ(coupled.getMeta("paragenesisStatus", ""), std::string("applied"));
CHECK(std::stoi(coupled.getMeta("parageneticChannels", "0")) > 0);
CHECK(std::stof(coupled.getMeta("maximumParageneticLift", "0")) > 0.f);
CHECK(std::stof(coupled.getMeta("meanParageneticWidth", "0")) > 0.f);
CHECK(std::stof(coupled.getMeta("meanPalaeofillRatio", "0")) > 0.6f);
CHECK(std::stof(coupled.getMeta("maximumAlluvialNotchRetreat", "0")) > 0.f);
CHECK(std::stof(coupled.getMeta("meanAlluvialNotchThickness", "0")) > 0.f);
params.setFloat("paragenesis", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.breakdownPairsCeilingScarsWithLandedBlocksDeterministically") {
const std::vector<CaveBreakdownChamber> chambers{{0.1f, 0.f, -0.2f, 0.35f, 0.22f, 0.3f}};
const auto first = createCaveBreakdown(chambers, 3, 0.8f, 20260830u);
const auto repeat = createCaveBreakdown(chambers, 3, 0.8f, 20260830u);
REQUIRE_EQ(first.events.size(), size_t(3));
CHECK_EQ(first.blockCount, repeat.blockCount);
CHECK_EQ(first.detachedVolume, repeat.detachedVolume);
CHECK_EQ(first.depositedVolume, repeat.depositedVolume);
CHECK(first.blockCount >= 6);
CHECK(first.detachedVolume > 0.f);
CHECK(first.depositedVolume > 0.f);
CHECK_EQ(first.events[0].x, repeat.events[0].x);
CHECK_EQ(first.events[0].ceilingY, repeat.events[0].ceilingY);
CHECK_EQ(first.events[0].blocks[0].x, repeat.events[0].blocks[0].x);
CHECK(first.events[0].blocks[0].y < first.events[0].ceilingY);
const auto& event = first.events[0];
CHECK(carveCaveBreakdownScars(event.x, event.ceilingY, event.z, 1.f, first) < 0.f);
const auto& block = event.blocks[0];
CHECK(addCaveBreakdownBlocks(block.x, block.y, block.z, -1.f, first) > 0.f);
CHECK(isCaveBreakdownBlockSurface(block.x + block.hx + 0.006f, block.y, block.z, 0.002f, first));
CHECK(createCaveBreakdown(chambers, 3, 0.f, 20260830u).events.empty());
}
TEST_CASE("procgen.mesh.cave.breakdownIsOptInPairedGroupedAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 30);
params.setInt("chambers", 4);
params.setInt("branches", 2);
params.setFloat("fragmentDetachment", 1.f);
MeshBuild baseline, first, repeat;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
CHECK_EQ(baseline.getMeta("breakdownModel", ""), std::string("disabled"));
params.setFloat("breakdown", 0.9f);
params.setInt("breakdownEvents", 4);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeat, error));
CHECK(first.positions() == repeat.positions());
CHECK(first.indices() == repeat.indices());
CHECK(first.positions() != baseline.positions());
CHECK_EQ(first.getMeta("breakdownModel", ""), std::string("paired-ceiling-spall-talus-v1"));
CHECK_EQ(std::stoi(first.getMeta("breakdownEvents", "0")), 4);
CHECK(std::stoi(first.getMeta("breakdownBlocks", "0")) >= 8);
CHECK(std::stof(first.getMeta("breakdownDetachedVolume", "0")) > 0.f);
CHECK(std::stof(first.getMeta("breakdownDepositedVolume", "0")) > 0.f);
int breakdownGroup = -1;
for (int group = 0; group < first.getGroupCount(); ++group)
if (first.getGroupName(group) == "breakdown") breakdownGroup = group;
REQUIRE(breakdownGroup >= 0);
const bool hasBreakdownGeometry = first.copyGroup(breakdownGroup) != nullptr;
CHECK(hasBreakdownGeometry);
params.setFloat("breakdown", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.differentialVeinErosionIsBoundedProtectedAndDeterministic") {
CaveDifferentialErosionInput input;
input.x = 0.21f;
input.y = -0.08f;
input.z = 0.37f;
input.distance = 0.17f;
input.radius = 0.16f;
input.strength = 1.f;
input.seed = 20260830u;
const auto first = sampleCaveDifferentialVeinErosion(input);
const auto repeat = sampleCaveDifferentialVeinErosion(input);
CHECK_EQ(first.hostRetreat, repeat.hostRetreat);
CHECK_EQ(first.veinProtection, repeat.veinProtection);
CHECK(first.hostRetreat >= 0.f);
CHECK(first.hostRetreat <= 0.040001f);
CHECK(first.veinProtection >= 0.f);
CHECK(first.veinProtection <= 1.f);
input.distance = 0.8f;
CHECK_EQ(sampleCaveDifferentialVeinErosion(input).hostRetreat, 0.f);
input.strength = 0.f;
CHECK_EQ(sampleCaveDifferentialVeinErosion(input).hostRetreat, 0.f);
}
TEST_CASE("procgen.mesh.cave.differentialVeinErosionIsOptInDistinctAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 24);
params.setInt("chambers", 4);
params.setInt("branches", 2);
MeshBuild baseline, first, repeat;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("differentialVeinErosion", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeat, error));
CHECK(first.positions() == repeat.positions());
CHECK(first.indices() == repeat.indices());
CHECK(first.positions() != baseline.positions());
CHECK_EQ(first.getMeta("differentialVeinModel", ""), std::string("resistant-vein-host-retreat-v1"));
CHECK(std::stoi(first.getMeta("differentialVeinAffectedVoxels", "0")) > 0);
CHECK(std::stof(first.getMeta("maximumDifferentialVeinRetreat", "0")) > 0.f);
CHECK(std::stof(first.getMeta("maximumVeinProtection", "0")) > 0.f);
params.setFloat("differentialVeinErosion", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.condensationFacetsArePlanarBoundedAndDeterministic") {
CaveFacetInput input;
input.along = 0.31f;
input.angle = 0.72f;
input.distance = 0.17f;
input.radius = 0.16f;
input.strength = 1.f;
input.seed = 20260830u;
const auto first = sampleCaveCondensationFacets(input);
const auto repeat = sampleCaveCondensationFacets(input);
CHECK_EQ(first.retreat, repeat.retreat);
CHECK_EQ(first.planarWeight, repeat.planarWeight);
CHECK(first.facetCount >= 5);
CHECK(first.facetCount <= 7);
CHECK(first.retreat > 0.f);
CHECK(first.retreat <= 0.055001f);
input.distance = 0.8f;
CHECK_EQ(sampleCaveCondensationFacets(input).retreat, 0.f);
input.strength = 0.f;
CHECK_EQ(sampleCaveCondensationFacets(input).retreat, 0.f);
}
TEST_CASE("procgen.mesh.cave.condensationFacetingIsOptInDistinctAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 24);
params.setInt("chambers", 4);
params.setInt("branches", 2);
MeshBuild baseline, first, repeat;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("condensationFaceting", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeat, error));
CHECK(first.positions() == repeat.positions());
CHECK(first.indices() == repeat.indices());
CHECK(first.positions() != baseline.positions());
CHECK_EQ(first.getMeta("condensationFacetModel", ""), std::string("local-convection-planar-envelope-v1"));
CHECK(std::stoi(first.getMeta("facetAffectedVoxels", "0")) > 0);
CHECK(std::stof(first.getMeta("maximumFacetRetreat", "0")) > 0.f);
params.setFloat("condensationFaceting", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.biogenicCorrosionErasesFluvialScallopsButFastFilmsProtectThem") {
CaveBiogenicCorrosionInput dry;
dry.along = 0.37f;
dry.angle = 1.2f;
dry.distance = 0.17f;
dry.radius = 0.16f;
dry.hydraulicExposure = 0.45f;
dry.strength = 0.9f;
dry.seed = 20260830u;
const auto first = sampleCaveBiogenicCorrosion(dry);
const auto repeat = sampleCaveBiogenicCorrosion(dry);
CHECK_EQ(first.erosion, repeat.erosion);
CHECK_EQ(first.fluvialScallopRetention, repeat.fluvialScallopRetention);
CHECK(first.erosion > 0.f);
CHECK(first.fluvialScallopRetention < 0.35f);
CaveBiogenicCorrosionInput wet = dry;
wet.hydraulicExposure = 1.45f;
const auto protectedSurface = sampleCaveBiogenicCorrosion(wet);
CHECK(protectedSurface.erosion < first.erosion);
CHECK(protectedSurface.fluvialScallopRetention > first.fluvialScallopRetention);
dry.strength = 0.f;
const auto disabled = sampleCaveBiogenicCorrosion(dry);
CHECK_EQ(disabled.erosion, 0.f);
CHECK_EQ(disabled.fluvialScallopRetention, 1.f);
}
TEST_CASE("procgen.mesh.cave.biogenicCorrosionIsOptInDistinctAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 24);
params.setInt("chambers", 4);
params.setInt("branches", 2);
params.setFloat("erosion", 0.f);
params.setFloat("scallopErosion", 0.f);
MeshBuild baseline, first, repeat;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("biogenicCorrosion", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeat, error));
CHECK(first.positions() == repeat.positions());
CHECK(first.indices() == repeat.indices());
CHECK(first.positions() != baseline.positions());
CHECK_EQ(first.getMeta("biogenicCorrosionModel", ""), std::string("ammonia-nitrification-aero-speleogen-v1"));
CHECK(std::stoi(first.getMeta("biogenicAffectedVoxels", "0")) > 0);
CHECK(std::stof(first.getMeta("minimumFluvialScallopRetention", "1")) < 1.f);
CHECK(std::stof(first.getMeta("maximumBiogenicErosion", "0")) > 0.f);
params.setFloat("biogenicCorrosion", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.condensationCorrosionIsShallowCeilingBiasedAndDeterministic") {
constexpr int n = 17;
auto index = [](int x, int y, int z) { return size_t(x + y * n + z * n * n); };
std::vector<float> density(size_t(n * n * n));
std::vector<float> exposure(density.size(), 0.35f);
for (int z = 0; z < n; ++z)
for (int y = 0; y < n; ++y)
for (int x = 0; x < n; ++x) {
const float px = float(x) / float(n - 1) * 2.f - 1.f;
const float py = float(y) / float(n - 1) * 2.f - 1.f;
const float pz = float(z) / float(n - 1) * 2.f - 1.f;
density[index(x, y, z)] = std::sqrt(px * px + py * py + pz * pz) - 0.62f;
}
const std::vector<float> original = density;
std::vector<float> repeated = density;
std::vector<float> disabled = density;
const auto disabledResult = erodeCaveByCondensation(disabled, exposure, n, n, n, 0.f, 20260830u);
CHECK(disabled == original);
CHECK_EQ(disabledResult.affectedVoxels, 0);
const auto result = erodeCaveByCondensation(density, exposure, n, n, n, 1.f, 20260830u);
const auto repeatedResult = erodeCaveByCondensation(repeated, exposure, n, n, n, 1.f, 20260830u);
CHECK(density == repeated);
CHECK_EQ(result.affectedVoxels, repeatedResult.affectedVoxels);
CHECK(result.affectedVoxels > 0);
CHECK(result.maximumRetreat > 0.f);
CHECK(result.maximumRetreat <= 0.032001f);
int upperChanged = 0, lowerChanged = 0;
for (int z = 1; z < n - 1; ++z)
for (int y = 1; y < n - 1; ++y)
for (int x = 1; x < n - 1; ++x)
if (density[index(x, y, z)] != original[index(x, y, z)]) {
if (y > n / 2) ++upperChanged;
if (y < n / 2) ++lowerChanged;
}
CHECK(upperChanged > lowerChanged * 4);
}
TEST_CASE("procgen.mesh.cave.condensationCorrosionIsObservableAndOptIn") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setInt("resolution", 24);
params.setInt("chambers", 4);
params.setInt("branches", 2);
params.setFloat("condensationCorrosion", 0.9f);
MeshBuild first, second;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, second, error));
CHECK(first.positions() == second.positions());
CHECK_EQ(first.getMeta("condensationCorrosionModel", ""), std::string("cool-wall-co2-film-pitting-v1"));
CHECK(std::stoi(first.getMeta("condensationAffectedVoxels", "0")) > 0);
CHECK(std::stof(first.getMeta("maximumCondensationRetreat", "0")) > 0.f);
params.setFloat("condensationCorrosion", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.stylesAreDeterministicAndDistinct") {
MeshRecipeRegistry::instance().registerBuiltins();
REQUIRE(MeshRecipeRegistry::instance().has("mesh.cave"));
const char* styles[] = {"cavern", "tunnels", "vertical", "labyrinth", "mixed"};
int previousVertices = -1;
for (const char* style : styles) {
Params params;
params.setSeed(20260830);
params.setString("style", style);
params.setInt("resolution", 28);
params.setInt("chambers", 5);
params.setInt("branches", 3);
MeshBuild first, second;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, first, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, second, error));
CHECK(first.getVertexCount() > 100);
CHECK_EQ(first.getIndexCount() % 3, 0);
CHECK(first.positions() == second.positions());
CHECK(first.indices() == second.indices());
CHECK_EQ(first.getMeta("style", ""), std::string(style));
CHECK_EQ(first.getMeta("determinism", ""), std::string("bit-exact-cpu"));
if (previousVertices >= 0) CHECK(first.getVertexCount() != previousVertices);
previousVertices = first.getVertexCount();
}
}
TEST_CASE("procgen.mesh.cave.parametersControlBoundsAndTopology") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(77);
params.setInt("resolution", 30);
params.setFloat("width", 42.f);
params.setFloat("height", 14.f);
params.setFloat("depth", 26.f);
params.setInt("chambers", 4);
params.setInt("branches", 1);
MeshBuild sparse, branched;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, sparse, error));
params.setInt("branches", 8);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, branched, error));
CHECK(sparse.positions() != branched.positions());
CHECK_EQ(branched.getMeta("branches", ""), std::string("8"));
float minX = std::numeric_limits<float>::max();
float maxX = std::numeric_limits<float>::lowest();
float minY = std::numeric_limits<float>::max();
float maxY = std::numeric_limits<float>::lowest();
for (int vertex = 0; vertex < branched.getVertexCount(); ++vertex) {
minX = std::min(minX, branched.getPositionX(vertex));
maxX = std::max(maxX, branched.getPositionX(vertex));
minY = std::min(minY, branched.getPositionY(vertex));
maxY = std::max(maxY, branched.getPositionY(vertex));
CHECK(std::fabs(branched.getPositionX(vertex)) <= 21.01f);
CHECK(std::fabs(branched.getPositionY(vertex)) <= 7.01f);
CHECK(std::fabs(branched.getPositionZ(vertex)) <= 13.01f);
const float nx = branched.getNormalX(vertex);
const float ny = branched.getNormalY(vertex);
const float nz = branched.getNormalZ(vertex);
CHECK(std::fabs(std::sqrt(nx * nx + ny * ny + nz * nz) - 1.f) < 1e-3f);
}
CHECK(minX < -8.f);
CHECK(maxX > 8.f);
CHECK(maxX - minX > 24.f);
CHECK(minY < -1.f);
CHECK(maxY > 1.f);
}
TEST_CASE("procgen.mesh.cave.rejectsInvalidInputs") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setString("style", "lava-tube-ish");
MeshBuild mesh;
std::string error;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("unknown style") != std::string::npos);
params.setString("style", "mixed");
params.setInt("resolution", 4);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("resolution") != std::string::npos);
params.setInt("resolution", 24);
params.setInt("surfaceRefinement", 3);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setInt("surfaceRefinement", 0);
params.setInt("isosurfaceSampling", 3);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setInt("isosurfaceSampling", 1);
params.setString("surfaceNormalMode", "invented");
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("surfaceNormalMode") != std::string::npos);
params.setString("surfaceNormalMode", "faceAverage");
params.setInt("wetnessRefinement", 2);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setInt("wetnessRefinement", 0);
params.setFloat("boundaryClosure", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("boundaryClosure", 0.f);
params.setFloat("permeabilityContrast", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("permeabilityContrast", 0.65f);
params.setFloat("bendUndercut", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("bendUndercut", 0.f);
params.setFloat("scallopMaturity", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("scallopMaturity", 0.f);
params.setFloat("fragmentDetachment", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("fragmentDetachment", 0.f);
params.setFloat("curvatureDissolution", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("curvatureDissolution", 0.f);
params.setFloat("reactiveSurfaceCoupling", 1.1f);
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("invalid") != std::string::npos);
params.setFloat("reactiveSurfaceCoupling", 0.f);
params.setString("genesis", "volcanic");
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, mesh, error));
CHECK(error.find("unknown genesis") != std::string::npos);
}
TEST_CASE("procgen.mesh.cave.microstructureControlsDistributedAndLocalizedDissolution") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260319);
params.setString("style", "tunnels");
params.setInt("resolution", 38);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("erosion", 0.95f);
params.setFloat("hydraulicErosion", 0.9f);
params.setFloat("microstructure", 0.f);
MeshBuild baseline, disabledWithDifferentRock, distributed, localized, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("microporosityAccess", 0.f);
params.setFloat("permeabilityContrast", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, disabledWithDifferentRock, error));
CHECK(baseline.positions() == disabledWithDifferentRock.positions());
CHECK(baseline.indices() == disabledWithDifferentRock.indices());
params.setFloat("microstructure", 1.f);
params.setFloat("microporosityAccess", 1.f);
params.setFloat("permeabilityContrast", 0.2f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, distributed, error));
params.setFloat("microporosityAccess", 0.f);
params.setFloat("permeabilityContrast", 0.95f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, localized, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(distributed.positions() != baseline.positions());
CHECK(localized.positions() != baseline.positions());
CHECK(distributed.positions() != localized.positions());
CHECK(localized.positions() == repeated.positions());
CHECK(localized.indices() == repeated.indices());
CHECK_EQ(localized.getMeta("erosionModel", ""), std::string("karst-reactive-microstructure-v6"));
CHECK_EQ(localized.getMeta("microstructureModel", ""), std::string("dual-scale-accessibility-permeability-v1"));
CHECK_EQ(distributed.getMeta("microporosityAccess", ""), std::string("1.000000"));
CHECK_EQ(localized.getMeta("permeabilityContrast", ""), std::string("0.950000"));
}
TEST_CASE("procgen.mesh.cave.hypogeneRisingFlowIsDistinctConnectedAndDeterministic") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(5322505);
params.setString("style", "labyrinth");
params.setInt("resolution", 36);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setString("genesis", "epigene");
MeshBuild epigene, hypogene, repeated, hypogeneWithVadose;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, epigene, error));
params.setString("genesis", "hypogene");
params.setInt("cupolas", 9);
params.setInt("feeders", 5);
params.setFloat("vadoseIncision", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogene, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
params.setFloat("vadoseIncision", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hypogeneWithVadose, error));
CHECK(epigene.positions() != hypogene.positions());
CHECK(hypogene.positions() == repeated.positions());
CHECK(hypogene.indices() == repeated.indices());
CHECK(hypogene.positions() == hypogeneWithVadose.positions());
CHECK_EQ(epigene.getMeta("cupolas", ""), std::string("0"));
CHECK_EQ(hypogene.getMeta("cupolas", ""), std::string("9"));
CHECK_EQ(hypogene.getMeta("feeders", ""), std::string("5"));
CHECK_EQ(hypogene.getMeta("risingFlowModel", ""), std::string("feeder-half-tube-cupola-v1"));
}
TEST_CASE("procgen.mesh.cave.karstErosionIsDeterministicAndObservable") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(41029);
params.setInt("resolution", 32);
params.setInt("chambers", 5);
params.setInt("branches", 4);
params.setFloat("erosion", 0.f);
MeshBuild uneroded, eroded, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, uneroded, error));
params.setFloat("erosion", 0.85f);
params.setFloat("bedding", 0.9f);
params.setFloat("fractureDissolution", 0.8f);
params.setFloat("vadoseIncision", 0.7f);
params.setInt("fractureCount", 8);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, eroded, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(uneroded.positions() != eroded.positions());
CHECK(eroded.positions() == repeated.positions());
CHECK(eroded.indices() == repeated.indices());
CHECK_EQ(eroded.getMeta("erosionModel", ""), std::string("karst-fracture-bedding-vadose-scallop-v2"));
CHECK_EQ(eroded.getMeta("determinism", ""), std::string("bit-exact-cpu"));
}
TEST_CASE("procgen.mesh.cave.hydraulicFlowFocusesReactiveErosion") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20250831);
params.setString("style", "tunnels");
params.setInt("resolution", 38);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("erosion", 0.9f);
params.setFloat("hydraulicErosion", 0.f);
MeshBuild legacy, legacyDifferentHydrology, lowFlow, highFlow, repeated, unfocused;
MeshBuild uniformDissolution, wormholeDissolution;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, legacy, error));
params.setFloat("hydraulicGradient", 1.8f);
params.setFloat("recharge", 0.1f);
params.setFloat("damkohler", 0.04f);
params.setFloat("transportG", 4.5f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, legacyDifferentHydrology, error));
CHECK(legacy.positions() == legacyDifferentHydrology.positions());
CHECK(legacy.indices() == legacyDifferentHydrology.indices());
params.setFloat("hydraulicErosion", 1.f);
params.setFloat("hydraulicGradient", 0.08f);
params.setFloat("recharge", 0.2f);
params.setFloat("flowFocusing", 0.85f);
params.setFloat("damkohler", 0.002f);
params.setFloat("transportG", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, lowFlow, error));
params.setFloat("hydraulicGradient", 1.2f);
params.setFloat("recharge", 0.9f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, highFlow, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
params.setFloat("flowFocusing", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, unfocused, error));
params.setFloat("flowFocusing", 0.85f);
params.setFloat("damkohler", 0.0002f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, uniformDissolution, error));
params.setFloat("damkohler", 0.02f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, wormholeDissolution, error));
CHECK(lowFlow.positions() != highFlow.positions());
CHECK(unfocused.positions() != highFlow.positions());
CHECK(uniformDissolution.positions() != highFlow.positions());
CHECK(wormholeDissolution.positions() != highFlow.positions());
CHECK(uniformDissolution.positions() != wormholeDissolution.positions());
CHECK(highFlow.positions() == repeated.positions());
CHECK(highFlow.indices() == repeated.indices());
CHECK_EQ(highFlow.getMeta("erosionModel", ""), std::string("karst-reactive-network-da-v5"));
CHECK_EQ(highFlow.getMeta("hydraulicNetwork", ""), std::string("tributary-confluence-feedback-v1"));
CHECK_EQ(highFlow.getMeta("hydraulicConfluences", ""), std::string("4"));
CHECK(std::stof(highFlow.getMeta("minimumFlowWeight", "1")) <
std::stof(highFlow.getMeta("maximumFlowWeight", "1")));
CHECK_EQ(highFlow.getMeta("hydraulicGradient", ""), std::string("1.200000"));
CHECK_EQ(highFlow.getMeta("recharge", ""), std::string("0.900000"));
CHECK_EQ(highFlow.getMeta("dissolutionRegime", ""), std::string("channeling"));
CHECK_EQ(uniformDissolution.getMeta("dissolutionRegime", ""), std::string("uniform"));
CHECK_EQ(wormholeDissolution.getMeta("dissolutionRegime", ""), std::string("wormholing"));
CHECK(std::stof(uniformDissolution.getMeta("reactantPenetration", "0")) >
std::stof(highFlow.getMeta("reactantPenetration", "0")));
CHECK(std::stof(highFlow.getMeta("reactantPenetration", "0")) >
std::stof(wormholeDissolution.getMeta("reactantPenetration", "0")));
}
TEST_CASE("procgen.mesh.cave.flowScallopsAreDirectionalDeterministicErosion") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20250033);
params.setString("style", "tunnels");
params.setInt("resolution", 42);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("fractureDissolution", 0.f);
params.setFloat("erosion", 0.9f);
params.setFloat("scallopErosion", 0.f);
MeshBuild smoothWall, scalloped, repeated, scalingWithoutFlow, fixedHydraulic, scaledHydraulic, scaledRepeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, smoothWall, error));
params.setFloat("scallopErosion", 1.f);
params.setFloat("scallopScale", 0.10f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, scalloped, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
params.setFloat("scallopHydraulicScaling", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, scalingWithoutFlow, error));
params.setFloat("hydraulicErosion", 1.f);
params.setFloat("hydraulicGradient", 1.1f);
params.setFloat("recharge", 0.9f);
params.setFloat("flowFocusing", 0.9f);
params.setFloat("scallopHydraulicScaling", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, fixedHydraulic, error));
params.setFloat("scallopHydraulicScaling", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, scaledHydraulic, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, scaledRepeated, error));
CHECK(smoothWall.positions() != scalloped.positions());
CHECK(scalloped.positions() == repeated.positions());
CHECK(scalloped.indices() == repeated.indices());
CHECK(scalloped.positions() == scalingWithoutFlow.positions());
CHECK(fixedHydraulic.positions() != scaledHydraulic.positions());
CHECK(scaledHydraulic.positions() == scaledRepeated.positions());
CHECK(scaledHydraulic.indices() == scaledRepeated.indices());
CHECK_EQ(scalloped.getMeta("scallopScale", ""), std::string("0.100000"));
CHECK_EQ(scalloped.getMeta("erosionModel", ""), std::string("karst-fracture-bedding-vadose-scallop-v2"));
CHECK_EQ(scaledHydraulic.getMeta("erosionModel", ""), std::string("karst-hydraulic-scallop-v7"));
CHECK(std::stof(scaledHydraulic.getMeta("minimumScallopScale", "1")) <
std::stof(scaledHydraulic.getMeta("maximumScallopScale", "0")));
}
TEST_CASE("procgen.mesh.cave.scallopScalePatchesAndFlowSeparationAreDeterministicOptIns") {
CaveScallopInput input;
input.along = 0.037f;
input.angle = 0.42f;
input.distance = 0.17f;
input.radius = 0.16f;
input.hydraulicIntensity = 0.9f;
input.baseScale = 0.1f;
input.maturity = 0.65f;
input.seed = 20250033u;
const CaveScallopSample legacy = sampleCaveScallops(input);
CHECK_EQ(legacy.scaleMultiplier, 1.f);
input.scaleVariability = 0.8f;
const CaveScallopSample varied = sampleCaveScallops(input);
CHECK_EQ(varied.scaleMultiplier, sampleCaveScallops(input).scaleMultiplier);
CHECK(varied.scaleMultiplier != 1.f);
CHECK(varied.scale != legacy.scale);
input.flowSeparation = 0.85f;
const CaveScallopSample separated = sampleCaveScallops(input);
CHECK_EQ(separated.erosion, sampleCaveScallops(input).erosion);
CHECK(separated.erosion != varied.erosion);
}
TEST_CASE("procgen.mesh.cave.scallopVariabilityAndSeparationAreObservableAndDefaultCompatible") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20250033);
params.setString("style", "tunnels");
params.setInt("resolution", 34);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("scallopErosion", 1.f);
MeshBuild legacy, explicitLegacy, varied, repeated, separated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, legacy, error));
params.setFloat("scallopScaleVariability", 0.f);
params.setFloat("scallopFlowSeparation", 0.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, explicitLegacy, error));
CHECK(legacy.positions() == explicitLegacy.positions());
params.setFloat("scallopScaleVariability", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, varied, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(varied.positions() != legacy.positions());
CHECK(varied.positions() == repeated.positions());
CHECK_EQ(varied.getMeta("scallopScaleDistribution", ""), std::string("correlated-lognormal-proxy-v1"));
CHECK(std::stof(varied.getMeta("scallopGeometricStdDev", "1")) > 1.f);
params.setFloat("scallopFlowSeparation", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, separated, error));
CHECK(separated.positions() != varied.positions());
CHECK_EQ(separated.getMeta("scallopFlowProfile", ""), std::string("slope-separated-travelling-wave-v2"));
params.setFloat("scallopScaleVariability", 1.1f);
MeshBuild invalid;
CHECK(!MeshRecipeRegistry::instance().generate("mesh.cave", params, invalid, error));
}
TEST_CASE("procgen.mesh.cave.curvedPassagesUndercutOuterBanksDeterministically") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20250481);
params.setString("style", "labyrinth");
params.setInt("resolution", 42);
params.setInt("branches", 0);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("fractureDissolution", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("scallopErosion", 1.f);
params.setFloat("bendUndercut", 0.f);
MeshBuild symmetric, undercut, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, symmetric, error));
params.setFloat("bendUndercut", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, undercut, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(symmetric.positions() != undercut.positions());
CHECK(undercut.positions() == repeated.positions());
CHECK(undercut.indices() == repeated.indices());
CHECK_EQ(undercut.getMeta("erosionModel", ""), std::string("karst-reactive-curvature-v8"));
CHECK_EQ(undercut.getMeta("bendErosionModel", ""), std::string("curvature-outer-bank-v1"));
CHECK_EQ(undercut.getMeta("bendUndercut", ""), std::string("1.000000"));
}
TEST_CASE("procgen.mesh.cave.matureScallopsCoarsenIntoSharpCellularRidges") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(37988469);
params.setString("style", "tunnels");
params.setInt("resolution", 42);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("roughness", 0.f);
params.setFloat("bedding", 0.f);
params.setFloat("fractureDissolution", 0.f);
params.setFloat("erosion", 1.f);
params.setFloat("scallopErosion", 1.f);
params.setFloat("scallopScale", 0.09f);
params.setFloat("scallopMaturity", 0.f);
MeshBuild young, mature, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, young, error));
params.setFloat("scallopMaturity", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, mature, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(young.positions() != mature.positions());
CHECK(mature.positions() == repeated.positions());
CHECK(mature.indices() == repeated.indices());
CHECK_EQ(mature.getMeta("erosionModel", ""), std::string("karst-reactive-coarsening-v9"));
CHECK_EQ(mature.getMeta("scallopEvolutionModel", ""), std::string("normal-ablation-coarsening-v1"));
CHECK_EQ(mature.getMeta("scallopMaturity", ""), std::string("0.800000"));
}
TEST_CASE("procgen.mesh.cave.fragmentDetachmentRemovesOnlyHostDisconnectedRock") {
constexpr int size = 5;
std::vector<float> density(size_t(size * size * size), -1.f);
auto index = [](int x, int y, int z) { return size_t(x + y * size + z * size * size); };
density[index(0, 2, 2)] = 1.f;
density[index(1, 2, 2)] = 1.f;
density[index(2, 2, 2)] = 1.f;
density[index(3, 3, 3)] = 1.f;
const std::vector<float> original = density;
const CaveDetachmentResult disabled = detachUnsupportedCaveFragments(density, size, size, size, 0.f);
CHECK(density == original);
CHECK_EQ(disabled.unsupportedVoxels, 0);
const CaveDetachmentResult detached = detachUnsupportedCaveFragments(density, size, size, size, 1.f);
CHECK(density[index(0, 2, 2)] > 0.f);
CHECK(density[index(1, 2, 2)] > 0.f);
CHECK(density[index(2, 2, 2)] > 0.f);
CHECK(density[index(3, 3, 3)] < 0.f);
CHECK_EQ(detached.unsupportedVoxels, 1);
CHECK_EQ(detached.detachedVoxels, 1);
}
TEST_CASE("procgen.mesh.cave.curvatureEvolutionRetreatsConvexWallsDeterministically") {
constexpr int size = 17;
auto index = [](int x, int y, int z) { return size_t(x + y * size + z * size * size); };
std::vector<float> density(size_t(size * size * size));
for (int z = 0; z < size; ++z) {
for (int y = 0; y < size; ++y) {
for (int x = 0; x < size; ++x) {
const float px = float(x - size / 2) * 2.f / float(size - 1);
const float py = float(y - size / 2) * 2.f / float(size - 1);
const float pz = float(z - size / 2) * 2.f / float(size - 1);
density[index(x, y, z)] = std::sqrt(px * px + py * py + pz * pz) - 0.45f;
}
}
}
const std::vector<float> original = density;
std::vector<float> repeated = density;
const auto disabled = evolveCaveSurfaceByCurvature(density, size, size, size, 0.f);
CHECK(density == original);
CHECK_EQ(disabled.affectedVoxels, 0);
const auto evolved = evolveCaveSurfaceByCurvature(density, size, size, size, 0.8f);
const auto repeatedResult = evolveCaveSurfaceByCurvature(repeated, size, size, size, 0.8f);
CHECK(density == repeated);
CHECK_EQ(evolved.affectedVoxels, repeatedResult.affectedVoxels);
CHECK(evolved.affectedVoxels > 0);
CHECK(evolved.maximumRetreat > 0.f);
CHECK(density[index(size / 2 + 4, size / 2, size / 2)] < original[index(size / 2 + 4, size / 2, size / 2)]);
CHECK(density[index(0, 0, 0)] == original[index(0, 0, 0)]);
}
TEST_CASE("procgen.mesh.cave.depositsAnchorToFinalDensitySurface") {
constexpr int size = 33;
std::vector<float> density(size_t(size * size * size));
for (int z = 0; z < size; ++z) {
for (int y = 0; y < size; ++y) {
for (int x = 0; x < size; ++x) {
const float px = float(x) / float(size - 1) * 2.f - 1.f;
const float py = float(y) / float(size - 1) * 2.f - 1.f;
const float pz = float(z) / float(size - 1) * 2.f - 1.f;
density[size_t(x + y * size + z * size * size)] = std::sqrt(px * px + py * py + pz * pz) - 0.65f;
}
}
}
const auto span = findCaveVerticalSpan(density, size, size, size, 0.f, 0.f, 0.1f);
REQUIRE(span.has_value());
CHECK(std::abs(span->floor.position.y + 0.65f) < 0.01f);
CHECK(std::abs(span->ceiling.position.y - 0.65f) < 0.01f);
CHECK(span->floor.rockNormal.y < -0.9f);
CHECK(span->ceiling.rockNormal.y > 0.9f);
const auto wall = projectToFinalCaveSurface(density, size, size, size, {0.58f, 0.1f, 0.f}, 0.2f);
REQUIRE(wall.has_value());
CHECK(std::abs(sampleCaveDensity(density, size, size, size, wall->position)) < 0.01f);
CHECK(wall->rockNormal.x > 0.9f);
CHECK(!findCaveVerticalSpan(density, size, size, size, 0.9f, 0.9f, 0.f).has_value());
CHECK(!projectToFinalCaveSurface(density, size, size, size, {0.f, 0.f, 0.f}, 0.2f).has_value());
}
TEST_CASE("procgen.mesh.cave.curvatureDissolutionIsObservableBeforeDeposition") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 38);
params.setInt("dripstones", 12);
params.setInt("flowstones", 7);
params.setInt("curtains", 5);
params.setFloat("curvatureDissolution", 0.f);
MeshBuild baseline, evolved, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, baseline, error));
params.setFloat("curvatureDissolution", 0.8f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, evolved, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(evolved.positions() == repeated.positions());
CHECK(evolved.indices() == repeated.indices());
CHECK(baseline.positions() != evolved.positions());
CHECK_EQ(evolved.getMeta("surfaceEvolutionModel", ""), std::string("convex-normal-retreat-v1"));
CHECK(std::stoi(evolved.getMeta("curvatureAffectedVoxels", "0")) > 0);
CHECK(std::stof(evolved.getMeta("maximumCurvatureRetreat", "0")) > 0.f);
}
TEST_CASE("procgen.mesh.cave.reactiveAccessibilityModulatesCurvatureRetreat") {
constexpr int size = 17;
auto index = [](int x, int y, int z) { return size_t(x + y * size + z * size * size); };
std::vector<float> density(size_t(size * size * size));
std::vector<float> rates(density.size(), 0.35f);
for (int z = 0; z < size; ++z) {
for (int y = 0; y < size; ++y) {
for (int x = 0; x < size; ++x) {
const float px = float(x - size / 2) * 2.f / float(size - 1);
const float py = float(y - size / 2) * 2.f / float(size - 1);
const float pz = float(z - size / 2) * 2.f / float(size - 1);
density[index(x, y, z)] = std::sqrt(px * px + py * py + pz * pz) - 0.45f;
if (x > size / 2) rates[index(x, y, z)] = 2.1f;
}
}
}
const std::vector<float> original = density;
const auto result = evolveCaveSurfaceByCurvature(density, rates, size, size, size, 0.8f);
const float fastRetreat =
original[index(size / 2 + 4, size / 2, size / 2)] - density[index(size / 2 + 4, size / 2, size / 2)];
const float slowRetreat =
original[index(size / 2 - 4, size / 2, size / 2)] - density[index(size / 2 - 4, size / 2, size / 2)];
CHECK(fastRetreat > slowRetreat * 3.f);
CHECK(result.minimumRateMultiplier < 0.5f);
CHECK(result.maximumRateMultiplier > 2.f);
CHECK(result.totalRetreat > result.maximumRetreat);
}
TEST_CASE("procgen.mesh.cave.surfaceRateCouplingChangesSameHydrologyDeterministically") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20251120);
params.setString("style", "tunnels");
params.setInt("resolution", 38);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("curvatureDissolution", 0.85f);
params.setFloat("microstructure", 0.9f);
params.setFloat("hydraulicErosion", 0.85f);
params.setFloat("reactiveSurfaceCoupling", 0.f);
MeshBuild uniform, coupled, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, uniform, error));
params.setFloat("reactiveSurfaceCoupling", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, coupled, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(uniform.positions() != coupled.positions());
CHECK(coupled.positions() == repeated.positions());
CHECK(coupled.indices() == repeated.indices());
CHECK_EQ(coupled.getMeta("surfaceRateModel", ""), std::string("microstructure-hydraulic-access-v1"));
CHECK(std::stof(coupled.getMeta("minimumSurfaceRate", "1")) < 1.f);
CHECK(std::stof(coupled.getMeta("maximumSurfaceRate", "1")) > 1.f);
}
TEST_CASE("procgen.mesh.cave.detachmentIsObservableAndDeterministic") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20251103);
params.setString("style", "mixed");
params.setInt("resolution", 42);
params.setInt("dripstones", 18);
params.setInt("flowstones", 8);
params.setInt("curtains", 6);
params.setFloat("erosion", 0.9f);
params.setFloat("fragmentDetachment", 0.f);
MeshBuild retained, detached, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, retained, error));
params.setFloat("fragmentDetachment", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, detached, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(detached.positions() == repeated.positions());
CHECK(detached.indices() == repeated.indices());
CHECK_EQ(detached.getMeta("detachmentModel", ""), std::string("host-rock-connectivity-v1"));
CHECK(std::stoi(detached.getMeta("detachedVoxels", "0")) > 0);
CHECK_EQ(std::stoi(detached.getMeta("unsupportedVoxels", "0")), std::stoi(detached.getMeta("detachedVoxels", "0")));
CHECK(retained.positions() != detached.positions());
}
TEST_CASE("procgen.mesh.cave.surfaceRefinementProjectsDeterministicDetail") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(7741397);
params.setString("style", "tunnels");
params.setInt("resolution", 30);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setFloat("scallopErosion", 0.9f);
params.setFloat("scallopScale", 0.10f);
params.setInt("surfaceRefinement", 0);
MeshBuild coarse, refined, adaptive, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, coarse, error));
params.setInt("surfaceRefinement", 1);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, refined, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK_EQ(refined.getIndexCount(), coarse.getIndexCount() * 4);
CHECK_EQ(refined.getVertexCount(), coarse.getVertexCount() * 4);
CHECK(refined.positions() == repeated.positions());
CHECK(refined.indices() == repeated.indices());
CHECK(refined.triangleGroups() == repeated.triangleGroups());
CHECK_EQ(refined.getMeta("surfaceProjection", ""), std::string("trilinear-newton-v1"));
CHECK_EQ(refined.getMeta("surfaceRefinement", ""), std::string("1"));
params.setInt("surfaceRefinement", 2);
params.setFloat("refinementThreshold", 0.0015f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, adaptive, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(adaptive.getIndexCount() > coarse.getIndexCount());
CHECK(adaptive.getIndexCount() < refined.getIndexCount());
CHECK(adaptive.positions() == repeated.positions());
CHECK(adaptive.triangleGroups() == repeated.triangleGroups());
CHECK(std::stoi(adaptive.getMeta("adaptiveSplitEdges", "0")) > 0);
CHECK(std::stoi(adaptive.getMeta("refinedSourceTriangles", "0")) > 0);
CHECK_EQ(adaptive.getMeta("refinementTriangulation", ""), std::string("conforming-edge-mask-v2"));
}
TEST_CASE("procgen.mesh.cave.trilinearSupersamplingPreservesSourceSamples") {
constexpr int size = 5;
std::vector<float> density(size_t(size * size * size));
auto index = [](int x, int y, int z, int width, int height) {
return size_t(x) + size_t(y) * size_t(width) + size_t(z) * size_t(width) * size_t(height);
};
for (int z = 0; z < size; ++z)
for (int y = 0; y < size; ++y)
for (int x = 0; x < size; ++x) density[index(x, y, z, size, size)] = float(x * x + 3 * y - 2 * z) - 8.5f;
const CaveResampledField doubled = resampleCaveDensity(density, size, size, size, 2);
CHECK_EQ(doubled.nx, 9);
CHECK_EQ(doubled.ny, 9);
CHECK_EQ(doubled.nz, 9);
for (int z = 0; z < size; ++z)
for (int y = 0; y < size; ++y)
for (int x = 0; x < size; ++x)
CHECK_EQ(doubled.density[index(x * 2, y * 2, z * 2, doubled.nx, doubled.ny)],
density[index(x, y, z, size, size)]);
CHECK_EQ(doubled.density[index(1, 0, 0, doubled.nx, doubled.ny)],
0.5f * (density[index(0, 0, 0, size, size)] + density[index(1, 0, 0, size, size)]));
}
TEST_CASE("procgen.mesh.cave.isosurfaceSupersamplingImprovesDeterministicTessellation") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(250609579);
params.setString("style", "mixed");
params.setInt("resolution", 30);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setInt("surfaceRefinement", 0);
params.setInt("isosurfaceSampling", 1);
MeshBuild native, supersampled, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, native, error));
params.setInt("isosurfaceSampling", 2);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, supersampled, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(supersampled.getVertexCount() > native.getVertexCount() * 2);
CHECK(supersampled.positions() == repeated.positions());
CHECK(supersampled.indices() == repeated.indices());
CHECK_EQ(supersampled.getMeta("isosurfaceReconstruction", ""), std::string("trilinear-supersample-v1"));
CHECK_EQ(supersampled.getMeta("extractionResolution", ""), std::string("59x35x59"));
CHECK_EQ(supersampled.getMeta("isosurfaceSampling", ""), std::string("2"));
}
TEST_CASE("procgen.mesh.cave.densityGradientTracksContinuousField") {
constexpr int n = 5;
std::vector<float> density(size_t(n * n * n));
for (int z = 0; z < n; ++z) {
for (int y = 0; y < n; ++y) {
for (int x = 0; x < n; ++x) {
const float px = float(x) / float(n - 1) * 2.f - 1.f;
const float py = float(y) / float(n - 1) * 2.f - 1.f;
const float pz = float(z) / float(n - 1) * 2.f - 1.f;
density[size_t(x + y * n + z * n * n)] = 2.f * px - 3.f * py + 0.5f * pz;
}
}
}
const CaveFieldPoint gradient = sampleCaveDensityGradient(density, n, n, n, {0.13f, -0.27f, 0.31f});
CHECK(std::fabs(gradient.x - 2.f) < 1e-4f);
CHECK(std::fabs(gradient.y + 3.f) < 1e-4f);
CHECK(std::fabs(gradient.z - 0.5f) < 1e-4f);
}
TEST_CASE("procgen.mesh.cave.dripstonesUseDistinctStableTriangleGroup") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20250317);
params.setString("style", "cavern");
params.setInt("resolution", 40);
params.setInt("chambers", 6);
params.setInt("dripstones", 20);
params.setFloat("dripstoneScale", 1.05f);
params.setString("stalagmiteShape", "mixed");
MeshBuild formations, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, formations, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK_EQ(formations.getGroupCount(), 3);
CHECK_EQ(formations.getGroupName(0), std::string("caveWalls"));
CHECK_EQ(formations.getGroupName(1), std::string("speleothems"));
CHECK_EQ(formations.getGroupName(2), std::string("wetWalls"));
int wallTriangles = 0;
int speleothemTriangles = 0;
int wetTriangles = 0;
for (int triangle = 0; triangle < formations.getIndexCount() / 3; ++triangle) {
if (formations.getTriangleGroup(triangle) == 0) ++wallTriangles;
if (formations.getTriangleGroup(triangle) == 1) ++speleothemTriangles;
if (formations.getTriangleGroup(triangle) == 2) ++wetTriangles;
}
CHECK(wallTriangles > 100);
CHECK(speleothemTriangles > 20);
CHECK(wetTriangles > 20);
CHECK(formations.positions() == repeated.positions());
CHECK(formations.triangleGroups() == repeated.triangleGroups());
CHECK_EQ(formations.getMeta("depositionModel", ""), std::string("damkohler-thin-film-ripple-v2"));
}
TEST_CASE("procgen.mesh.cave.normalSmoothingChangesShadingNotTopology") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(9981);
params.setInt("resolution", 32);
params.setInt("dripstones", 0);
params.setFloat("normalSmoothing", 0.f);
MeshBuild faceted, smooth, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, faceted, error));
params.setFloat("normalSmoothing", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, smooth, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(faceted.positions() == smooth.positions());
CHECK(faceted.indices() == smooth.indices());
CHECK(faceted.normals() != smooth.normals());
CHECK(smooth.normals() == repeated.normals());
CHECK_EQ(smooth.getMeta("wetnessModel", ""), std::string("drainage-proximity-v1"));
for (int vertex = 0; vertex < smooth.getVertexCount(); ++vertex) {
const float nx = smooth.getNormalX(vertex);
const float ny = smooth.getNormalY(vertex);
const float nz = smooth.getNormalZ(vertex);
CHECK(std::fabs(std::sqrt(nx * nx + ny * ny + nz * nz) - 1.f) < 1e-3f);
}
}
TEST_CASE("procgen.mesh.cave.densityGradientNormalsAreDeterministicAndPreserveTopology") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(9981);
params.setInt("resolution", 32);
params.setInt("dripstones", 0);
params.setFloat("normalSmoothing", 1.f);
MeshBuild faceAverage, gradient, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, faceAverage, error));
params.setString("surfaceNormalMode", "densityGradient");
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, gradient, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(faceAverage.positions() == gradient.positions());
CHECK(faceAverage.indices() == gradient.indices());
CHECK(faceAverage.normals() != gradient.normals());
CHECK(gradient.normals() == repeated.normals());
CHECK_EQ(gradient.getMeta("surfaceNormalMode", ""), std::string("densityGradient"));
for (int vertex = 0; vertex < gradient.getVertexCount(); ++vertex) {
const float nx = gradient.getNormalX(vertex);
const float ny = gradient.getNormalY(vertex);
const float nz = gradient.getNormalZ(vertex);
CHECK(std::fabs(std::sqrt(nx * nx + ny * ny + nz * nz) - 1.f) < 1e-3f);
}
}
TEST_CASE("procgen.mesh.cave.wetnessContourRefinesOnlyMaterialBoundaryDeterministically") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 36);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
params.setInt("wetnessRefinement", 0);
MeshBuild coarse, refined, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, coarse, error));
params.setInt("wetnessRefinement", 1);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, refined, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(refined.getIndexCount() > coarse.getIndexCount());
CHECK(refined.positions() == repeated.positions());
CHECK(refined.indices() == repeated.indices());
CHECK(refined.triangleGroups() == repeated.triangleGroups());
CHECK_EQ(refined.getMeta("wetnessModel", ""), std::string("gravity-drainage-contour-v2"));
CHECK(std::stoi(refined.getMeta("wetnessBoundaryTriangles", "0")) > 0);
CHECK(std::stoi(refined.getMeta("wetnessAddedTriangles", "0")) > 0);
int dryTriangles = 0, wetTriangles = 0;
for (int triangle = 0; triangle < refined.getIndexCount() / 3; ++triangle) {
if (refined.getTriangleGroup(triangle) == 0) ++dryTriangles;
if (refined.getTriangleGroup(triangle) == 2) ++wetTriangles;
}
CHECK(dryTriangles > 0);
CHECK(wetTriangles > 0);
}
TEST_CASE("procgen.mesh.cave.boundaryClosureBuildsRoughHostRockEnvelope") {
constexpr int n = 9;
std::vector<float> density(size_t(n * n * n), -1.f);
const CaveBoundaryClosure closure = closeCaveDensityBoundary(density, n, n, n, 1.f, 20260830u);
CHECK(closure.airSamplesBefore > 0);
CHECK_EQ(closure.airSamplesAfter, 0);
CHECK(closure.changedVoxels > 0);
for (int z = 0; z < n; ++z) {
for (int y = 0; y < n; ++y) {
for (int x = 0; x < n; ++x) {
if (x == 0 || y == 0 || z == 0 || x == n - 1 || y == n - 1 || z == n - 1)
CHECK(density[size_t(x + y * n + z * n * n)] >= 0.f);
}
}
}
CHECK_EQ(density[size_t(4 + 4 * n + 4 * n * n)], -1.f);
}
TEST_CASE("procgen.mesh.cave.sealedDomainRemovesBoundaryAirDeterministically") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 40);
params.setInt("chambers", 8);
params.setFloat("chamberScale", 1.05f);
params.setFloat("tunnelRadius", 0.16f);
params.setInt("dripstones", 0);
params.setFloat("boundaryClosure", 0.f);
MeshBuild open, sealed, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, open, error));
params.setFloat("boundaryClosure", 1.f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, sealed, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(std::stoi(open.getMeta("boundaryAirSamplesBefore", "0")) > 0);
CHECK_EQ(open.getMeta("boundaryAirSamplesAfter", ""), open.getMeta("boundaryAirSamplesBefore", ""));
CHECK_EQ(sealed.getMeta("boundaryAirSamplesAfter", "-1"), std::string("0"));
CHECK(std::stoi(sealed.getMeta("boundaryClosureChangedVoxels", "0")) > 0);
CHECK(open.positions() != sealed.positions());
CHECK(sealed.positions() == repeated.positions());
CHECK(sealed.indices() == repeated.indices());
CHECK_EQ(sealed.getMeta("boundaryClosureModel", ""), std::string("rough-host-envelope-v1"));
}
TEST_CASE("procgen.mesh.cave.hierarchicalMacroMorphologyIsOptInAndDeterministic") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(20260830);
params.setString("style", "mixed");
params.setInt("resolution", 36);
params.setInt("chambers", 7);
params.setInt("dripstones", 0);
MeshBuild legacy, hierarchical, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, legacy, error));
CHECK_EQ(legacy.getMeta("macroMorphologyModel", ""), std::string("uniform-chambers-v1"));
params.setFloat("chamberHierarchy", 0.9f);
params.setFloat("passageVariation", 0.8f);
params.setFloat("chamberIrregularity", 0.7f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, hierarchical, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK_EQ(hierarchical.getMeta("macroMorphologyModel", ""), std::string("hierarchical-primary-hall-v2"));
CHECK(std::stof(hierarchical.getMeta("primaryChamberVerticalRadius", "0")) > 0.3f);
CHECK(legacy.positions() != hierarchical.positions());
CHECK(hierarchical.positions() == repeated.positions());
CHECK(hierarchical.indices() == repeated.indices());
}
TEST_CASE("procgen.mesh.cave.flowstonesAndCurtainsChangeDepositionalGeometry") {
MeshRecipeRegistry::instance().registerBuiltins();
Params params;
params.setSeed(2568);
params.setString("style", "cavern");
params.setInt("resolution", 40);
params.setInt("dripstones", 0);
params.setInt("flowstones", 0);
params.setInt("curtains", 0);
MeshBuild bare, deposited, repeated;
std::string error;
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, bare, error));
params.setInt("flowstones", 12);
params.setInt("curtains", 10);
params.setFloat("flowstoneScale", 1.15f);
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, deposited, error));
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, repeated, error));
CHECK(bare.positions() != deposited.positions());
CHECK(deposited.positions() == repeated.positions());
CHECK(deposited.indices() == repeated.indices());
int depositTriangles = 0;
for (int triangle = 0; triangle < deposited.getIndexCount() / 3; ++triangle)
if (deposited.getTriangleGroup(triangle) == 1) ++depositTriangles;
CHECK(depositTriangles > 20);
CHECK_EQ(deposited.getMeta("flowstones", ""), std::string("12"));
CHECK_EQ(deposited.getMeta("curtains", ""), std::string("10"));
}
Reference in new issue View Git Blame Copy Permalink