271 lines
13 KiB
C++
271 lines
13 KiB
C++
#include "CaveFixtures.h"
|
|
|
|
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));
|
|
|
|
REQUIRE_EQ(formations.getGroupCount(), 5);
|
|
REQUIRE_EQ(formations.getGroupName(3), std::string("breakdown"));
|
|
REQUIRE_EQ(formations.getGroupName(4), std::string("sediment"));
|
|
REQUIRE_EQ(formations.getGroupName(0), std::string("caveWalls"));
|
|
REQUIRE_EQ(formations.getGroupName(1), std::string("speleothems"));
|
|
REQUIRE_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;
|
|
}
|
|
REQUIRE(wallTriangles > 100);
|
|
REQUIRE(speleothemTriangles > 20);
|
|
REQUIRE(wetTriangles > 20);
|
|
REQUIRE(formations.positions() == repeated.positions());
|
|
REQUIRE(formations.triangleGroups() == repeated.triangleGroups());
|
|
REQUIRE_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", 24);
|
|
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));
|
|
|
|
REQUIRE(faceted.positions() == smooth.positions());
|
|
REQUIRE(faceted.indices() == smooth.indices());
|
|
REQUIRE(faceted.normals() != smooth.normals());
|
|
REQUIRE(smooth.normals() == repeated.normals());
|
|
REQUIRE_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);
|
|
REQUIRE(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", 24);
|
|
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));
|
|
|
|
REQUIRE(faceAverage.positions() == gradient.positions());
|
|
REQUIRE(faceAverage.indices() == gradient.indices());
|
|
REQUIRE(faceAverage.normals() != gradient.normals());
|
|
REQUIRE(gradient.normals() == repeated.normals());
|
|
REQUIRE_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);
|
|
REQUIRE(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", 24);
|
|
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));
|
|
|
|
REQUIRE(refined.getIndexCount() > coarse.getIndexCount());
|
|
REQUIRE(refined.positions() == repeated.positions());
|
|
REQUIRE(refined.indices() == repeated.indices());
|
|
REQUIRE(refined.triangleGroups() == repeated.triangleGroups());
|
|
REQUIRE_EQ(refined.getMeta("wetnessModel", ""), std::string("gravity-drainage-contour-v2"));
|
|
REQUIRE(std::stoi(refined.getMeta("wetnessBoundaryTriangles", "0")) > 0);
|
|
REQUIRE(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;
|
|
}
|
|
REQUIRE(dryTriangles > 0);
|
|
REQUIRE(wetTriangles > 0);
|
|
}
|
|
|
|
TEST_CASE("procgen.mesh.cave.boundaryClosureBuildsRoughHostRockEnvelope") {
|
|
constexpr int n = 9;
|
|
std::vector<float> density(size_t(n * n * n), -0.5f);
|
|
const CaveBoundaryClosure closure = closeCaveDensityBoundary(density, n, n, n, 1.f, 20260830u);
|
|
REQUIRE(closure.airSamplesBefore > 0);
|
|
REQUIRE_EQ(closure.airSamplesAfter, 0);
|
|
REQUIRE(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)
|
|
REQUIRE(density[size_t(x + y * n + z * n * n)] >= 0.f);
|
|
}
|
|
}
|
|
}
|
|
REQUIRE_EQ(density[size_t(4 + 4 * n + 4 * n * n)], -0.5f);
|
|
}
|
|
|
|
TEST_CASE("procgen.mesh.cave.sealedDomainRemovesBoundaryAirDeterministically") {
|
|
MeshRecipeRegistry::instance().registerBuiltins();
|
|
Params params;
|
|
params.setSeed(20260830);
|
|
params.setString("style", "mixed");
|
|
params.setInt("resolution", 24);
|
|
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));
|
|
|
|
REQUIRE(std::stoi(open.getMeta("boundaryAirSamplesBefore", "0")) > 0);
|
|
REQUIRE_EQ(open.getMeta("boundaryAirSamplesAfter", ""), open.getMeta("boundaryAirSamplesBefore", ""));
|
|
REQUIRE_EQ(sealed.getMeta("boundaryAirSamplesAfter", "-1"), std::string("0"));
|
|
REQUIRE(std::stoi(sealed.getMeta("boundaryClosureChangedVoxels", "0")) > 0);
|
|
REQUIRE(open.positions() != sealed.positions());
|
|
REQUIRE(sealed.positions() == repeated.positions());
|
|
REQUIRE(sealed.indices() == repeated.indices());
|
|
REQUIRE_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", 24);
|
|
params.setInt("chambers", 7);
|
|
params.setInt("dripstones", 0);
|
|
MeshBuild legacy, hierarchical, repeated;
|
|
std::string error;
|
|
REQUIRE(MeshRecipeRegistry::instance().generate("mesh.cave", params, legacy, error));
|
|
REQUIRE_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));
|
|
REQUIRE_EQ(hierarchical.getMeta("macroMorphologyModel", ""), std::string("hierarchical-primary-hall-v2"));
|
|
REQUIRE(std::stof(hierarchical.getMeta("primaryChamberVerticalRadius", "0")) > 0.3f);
|
|
REQUIRE(legacy.positions() != hierarchical.positions());
|
|
REQUIRE(hierarchical.positions() == repeated.positions());
|
|
REQUIRE(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"));
|
|
}
|