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

419 lines
19 KiB
C++
Raw Permalink Blame History

#include <algorithm>
#include <limits>
#include <vector>
#include <simplesquirrel/simplesquirrel.hpp>
#include "procgen/heightmap/Heightmap.h"
#include "procgen/heightmap/TerrainDetailLayer.h"
#include "procgen/heightmap/TerrainMultiTile.h"
#include "procgen/heightmap/TerrainStamp.h"
#include "procgen/heightmap/TerrainStampScript.h"
#include "procgen/heightmap/TerrainTreePlacement.h"
#include "procgen/PointSet.h"
#include "zeroerr/unittest.h"
using namespace eve::procgen;
namespace {
Heightmap filled(int width, int height, float value) {
Heightmap result(width, height);
std::fill(result.data().begin(), result.data().end(), value);
return result;
}
TerrainStampSettings setStamp(double x, double z, double width, double depth) {
TerrainStampSettings settings;
settings.centerX = x; settings.centerZ = z; settings.width = width; settings.depth = depth;
settings.operation = TerrainStampOperation::Set;
return settings;
}
} // namespace
TEST_CASE("procgen.multitile.pcgHeightmapSeamPixelMappingAndAtomicCommit") {
Heightmap a = filled(3, 3, 0), b = filled(3, 3, 0), stamp = filled(1, 1, 7), one = filled(1, 1, 1);
std::vector<TerrainHeightTile> tiles{{"west", &a, 0, 0, 2, 2, false},
{"east", &b, 2, 0, 2, 2, false}};
auto report = applyTerrainStampMultiTile(tiles, stamp, setStamp(2, 1, 2, 2), one, one);
REQUIRE(report.ok());
CHECK(report.value().affectedTiles == 2);
CHECK(report.value().operationX == 1);
CHECK(report.value().operationWidth == 3);
REQUIRE(report.value().mappings.size() == 2);
CHECK(report.value().mappings[0].localX == 1);
CHECK(report.value().mappings[0].operationX == 0);
CHECK(report.value().mappings[0].width == 2);
CHECK(report.value().mappings[1].localX == 0);
CHECK(report.value().mappings[1].operationX == 1);
CHECK(report.value().mappings[1].width == 2);
CHECK(a.height(2, 1) == 7);
CHECK(b.height(0, 1) == 7);
}
TEST_CASE("procgen.multitile.operationDomainsUsePcgSeamStride") {
TerrainStampSettings settings = setStamp(2, 1, 2, 2);
std::vector<TerrainOperationTile> tiles = {
{"west", 0, 0, 2, 2, 3, 3, false},
{"east", 2, 0, 2, 2, 3, 3, false},
};
auto height = mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::Heightmap);
REQUIRE(height.ok());
CHECK(height.value().operationX == 1);
CHECK(height.value().operationWidth == 3);
REQUIRE(height.value().mappings.size() == 2);
CHECK(height.value().mappings[0].operationX == 0);
CHECK(height.value().mappings[0].width == 2);
CHECK(height.value().mappings[1].operationX == 1);
CHECK(height.value().mappings[1].width == 2);
auto detail = mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::TerrainDetail);
REQUIRE(detail.ok());
CHECK(detail.value().operationX == 1);
CHECK(detail.value().operationWidth == 4);
REQUIRE(detail.value().mappings.size() == 2);
CHECK(detail.value().mappings[0].operationX == 0);
CHECK(detail.value().mappings[0].width == 2);
CHECK(detail.value().mappings[1].operationX == 2);
CHECK(detail.value().mappings[1].width == 2);
tiles[1].worldMap = true;
auto ordinary = mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::Texture);
REQUIRE(ordinary.ok());
CHECK(ordinary.value().affectedTiles == 1);
auto selectedWorld = mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::GameObject, true,
{"east"});
REQUIRE(selectedWorld.ok());
CHECK(selectedWorld.value().affectedTiles == 1);
CHECK(selectedWorld.value().mappings[0].terrainName == "east");
tiles[1].name = "west";
CHECK(!mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::Tree).ok());
tiles[1].name = "east";
tiles[1].originX = 2.25;
CHECK(!mapTerrainOperationMultiTile(tiles, settings, TerrainOperationDomain::BakedMask).ok());
}
TEST_CASE("procgen.multitile.detailReplaceUsesSharedWindowAndAtomicPublish") {
TerrainDetailLayer west, east;
REQUIRE(west.reset(3, 3, 1).ok());
REQUIRE(east.reset(3, 3, 1).ok());
std::vector<TerrainDetailTile> tiles = {
{"west", &west, 0, 0, 2, 2, false},
{"east", &east, 2, 0, 2, 2, false},
};
Heightmap fitness = filled(4, 3, 1);
TerrainDetailSettings detail;
detail.minimumFitness = 0;
detail.fadeStart = 0;
detail.density = 4;
detail.mode = TerrainDetailMode::Replace;
auto result = applyTerrainDetailMultiTile(tiles, fitness, detail, setStamp(2, 1, 2, 2), 77);
REQUIRE(result.ok());
CHECK(result.value().affectedTiles == 2);
CHECK(result.value().changedSamples == 18);
CHECK(west.sample(0, 1).value() == 0);
CHECK(west.sample(1, 1).value() == 4);
CHECK(west.sample(2, 1).value() == 4);
CHECK(east.sample(0, 1).value() == 4);
CHECK(east.sample(1, 1).value() == 4);
CHECK(east.sample(2, 1).value() == 0);
Heightmap wrong = filled(3, 3, 0);
const int beforeWest = west.sample(1, 1).value();
const int beforeEast = east.sample(0, 1).value();
CHECK(!applyTerrainDetailMultiTile(tiles, wrong, detail, setStamp(2, 1, 2, 2), 77).ok());
CHECK(west.sample(1, 1).value() == beforeWest);
CHECK(east.sample(0, 1).value() == beforeEast);
tiles[1].layer = &west;
CHECK(!applyTerrainDetailMultiTile(tiles, fitness, detail, setStamp(2, 1, 2, 2), 77).ok());
CHECK(west.sample(1, 1).value() == beforeWest);
}
TEST_CASE("procgen.multitile.detailWorkspaceOwnsHistoryAndScriptBinding") {
TerrainDetailLayer source, output;
REQUIRE(source.reset(3, 3, 1).ok());
REQUIRE(output.reset(3, 3, 0).ok());
Heightmap fitness = filled(4, 3, 1);
TerrainDetailSettings detail;
detail.minimumFitness = detail.fadeStart = 0;
detail.density = 5;
TerrainMultiDetailWorkspace workspace;
REQUIRE(workspace.addTile("west", source, 0, 0, 2, 2).ok());
REQUIRE(workspace.addTile("east", source, 2, 0, 2, 2).ok());
REQUIRE(workspace.apply(fitness, detail, setStamp(2, 1, 2, 2), 9).ok());
CHECK(workspace.getTileCount() == 2);
CHECK(workspace.getLastAffectedTiles() == 2);
CHECK(workspace.getOperationCount() == 1);
REQUIRE(workspace.copyTile("east", output).ok());
CHECK(output.sample(0, 1).value() == 5);
REQUIRE(workspace.undo().ok());
REQUIRE(workspace.copyTile("east", output).ok());
CHECK(output.sample(0, 1).value() == 1);
REQUIRE(workspace.redo().ok());
CHECK(workspace.getAppliedCount() == 1);
ssq::VM vm(1024);
auto table = vm.addTable("eve");
exposeHeightmap(table);
vm.addFunc("source", [&]() { return &source; });
vm.addFunc("fitness", [&]() { return &fitness; });
vm.addFunc("output", [&]() { return &output; });
vm.run(vm.compileSource(R"(
local w=eve.TerrainMultiDetailWorkspace();
assert(w.addTile("west",source(),0.0,0.0,2.0,2.0,false).ok);
assert(w.addTile("east",source(),2.0,0.0,2.0,2.0,false).ok);
local d=eve.TerrainDetailSettings();d.minimumFitness=0.0;d.fadeStart=0.0;d.density=6.0;
local s=eve.TerrainStampSettings();s.setCenter(2.0,1.0);s.setSize(2.0,2.0);
assert(w.apply(fitness(),d,s,0,11,false).ok);
assert(w.getTileCount()==2 && w.getLastAffectedTiles()==2 && w.getLastChangedSamples()==18);
assert(w.copyTile("east",output()).ok && output().sample(0,1).value==6);
assert(w.undo().ok && w.copyTile("east",output()).ok && output().sample(0,1).value==1);
assert(w.redo().ok && w.getOperationCount()==1 && w.getAppliedCount()==1);
)"));
}
TEST_CASE("procgen.multitile.treeSharedStreamAddRemoveAndAtomicFailure") {
PointSet west, east;
Heightmap heights = filled(2, 2, 0.25F);
Heightmap fitness = filled(4, 2, 1);
std::vector<TerrainTreeTile> tiles = {
{"west", &west, &heights, 0, 0, 2, 2, 2, 2, false},
{"east", &east, &heights, 2, 0, 2, 2, 2, 2, false},
};
TerrainTreePlacementSettings tree;
tree.spacing = tree.spawnDensity = 1;
tree.jitterPercent = tree.failureRate = tree.minimumFitness = 0;
tree.scaleMode = TerrainTreeScaleMode::Fixed;
tree.minimumWidth = tree.maximumWidth = tree.minimumHeight = tree.maximumHeight = 1;
tree.asset = "oak";
tree.namespaceId = 42;
tree.maxPoints = 100;
tree.seed = 19;
auto bounds = setStamp(2, 1, 4, 2);
auto added = applyTerrainTreesMultiTile(tiles, fitness, tree, bounds, TerrainTreeOperationMode::Add);
REQUIRE(added.ok());
CHECK(added.value().affectedTiles == 2);
CHECK(added.value().changedSamples == 8);
CHECK(west.getCount() == 4);
CHECK(east.getCount() == 4);
CHECK(west.hasIntAttribute(0, "treeCandidate"));
CHECK(east.hasIntAttribute(0, "treeCandidate"));
CHECK(west.getIntAttribute(0, "treeCandidate", -1) != east.getIntAttribute(0, "treeCandidate", -1));
std::vector<std::uint64_t> ids;
for (const auto& point : west.points()) ids.push_back(point.id);
for (const auto& point : east.points()) ids.push_back(point.id);
std::sort(ids.begin(), ids.end());
CHECK(std::adjacent_find(ids.begin(), ids.end()) == ids.end());
Heightmap wrong = filled(3, 2, 1);
CHECK(!applyTerrainTreesMultiTile(tiles, wrong, tree, bounds, TerrainTreeOperationMode::Add).ok());
CHECK(west.getCount() == 4);
CHECK(east.getCount() == 4);
PointSet existing;
existing.add(99, 0, 99);
tiles[0].trees = &existing;
tree.maxPoints = 8;
auto budgetIgnoresExisting = applyTerrainTreesMultiTile(tiles, fitness, tree, bounds, TerrainTreeOperationMode::Add);
REQUIRE(budgetIgnoresExisting.ok());
CHECK(existing.getCount() == 5);
tree.maxPoints = 100;
tiles[0].trees = &west;
auto removed = applyTerrainTreesMultiTile(tiles, fitness, tree, bounds, TerrainTreeOperationMode::Remove);
REQUIRE(removed.ok());
CHECK(removed.value().changedSamples == 8);
CHECK(west.empty());
CHECK(east.empty());
}
TEST_CASE("procgen.multitile.treeWorkspaceOwnsHistoryAndScriptBinding") {
PointSet empty, output;
Heightmap heights = filled(2, 2, 0.25F), fitness = filled(4, 2, 1);
TerrainTreePlacementSettings tree;
tree.spacing = tree.spawnDensity = 1;
tree.jitterPercent = tree.failureRate = tree.minimumFitness = 0;
tree.scaleMode = TerrainTreeScaleMode::Fixed;
tree.minimumWidth = tree.maximumWidth = tree.minimumHeight = tree.maximumHeight = 1;
tree.asset = "oak"; tree.namespaceId = 77; tree.maxPoints = 100; tree.seed = 5;
auto bounds = setStamp(2, 1, 4, 2);
TerrainMultiTreeWorkspace workspace;
REQUIRE(workspace.addTile("west", empty, heights, 0, 0, 2, 2, 2, 2).ok());
REQUIRE(workspace.addTile("east", empty, heights, 2, 0, 2, 2, 2, 2).ok());
REQUIRE(workspace.apply(fitness, tree, bounds, TerrainTreeOperationMode::Add).ok());
REQUIRE(workspace.copyTile("east", output).ok());
CHECK(output.getCount() == 4);
REQUIRE(workspace.undo().ok());
REQUIRE(workspace.copyTile("east", output).ok());
CHECK(output.empty());
REQUIRE(workspace.redo().ok());
CHECK(workspace.getTileCount() == 2);
CHECK(workspace.getLastChangedSamples() == 8);
CHECK(workspace.getOperationCount() == 1);
CHECK(workspace.getAppliedCount() == 1);
ssq::VM vm(1024);
auto table = vm.addTable("eve");
exposeHeightmap(table);
vm.addFunc("emptyTrees", [&]() { return &empty; });
vm.addFunc("heights", [&]() { return &heights; });
vm.addFunc("fitness", [&]() { return &fitness; });
vm.addFunc("output", [&]() { return &output; });
vm.addFunc("pointCount", [](const PointSet* points) { return points->getCount(); });
vm.run(vm.compileSource(R"(
local w=eve.TerrainMultiTreeWorkspace();
assert(w.addTile("west",emptyTrees(),heights(),0.0,0.0,2.0,2.0,2,2,false).ok);
assert(w.addTile("east",emptyTrees(),heights(),2.0,0.0,2.0,2.0,2,2,false).ok);
local t=eve.TerrainTreePlacementSettings();t.spacing=1.0;t.spawnDensity=1.0;
t.jitterPercent=0.0;t.failureRate=0.0;t.minimumFitness=0.0;t.asset="oak";
t.namespaceId=91;t.maxPoints=100;t.seed=5;t.setScaleMode(0);
local s=eve.TerrainStampSettings();s.setCenter(2.0,1.0);s.setSize(4.0,2.0);
assert(w.apply(fitness(),t,s,0,false).ok);
assert(w.copyTile("east",output()).ok && pointCount(output())==4);
assert(w.getTileCount()==2 && w.getLastAffectedTiles()==2 && w.getLastChangedSamples()==8);
assert(w.undo().ok && w.copyTile("east",output()).ok && pointCount(output())==0);
assert(w.redo().ok && w.getOperationCount()==1 && w.getAppliedCount()==1);
)"));
}
TEST_CASE("procgen.multitile.touchOnlyAllowListAndWorldMapDomain") {
Heightmap a = filled(3, 3, 0), b = filled(3, 3, 0), world = filled(3, 3, 0);
Heightmap stamp = filled(1, 1, 4), one = filled(1, 1, 1);
std::vector<TerrainHeightTile> tiles{{"a", &a, 0, 0, 2, 2, false},
{"b", &b, 2, 0, 2, 2, false},
{"world", &world, 0, 0, 2, 2, true}};
auto ordinary = applyTerrainStampMultiTile(tiles, stamp, setStamp(1, 1, 2, 2), one, one, false, {"a", "b"});
REQUIRE(ordinary.ok());
CHECK(ordinary.value().affectedTiles == 1);
CHECK(a.height(1, 1) == 4);
CHECK(b.height(0, 1) == 0);
CHECK(world.height(1, 1) == 0);
auto worldOnly = applyTerrainStampMultiTile(tiles, stamp, setStamp(1, 1, 2, 2), one, one, true);
REQUIRE(worldOnly.ok());
CHECK(worldOnly.value().affectedTiles == 1);
CHECK(world.height(1, 1) == 4);
}
TEST_CASE("procgen.multitile.lateFailureAndDescriptorErrorsPreserveEveryTile") {
Heightmap a = filled(2, 2, 1), b = filled(2, 2, std::numeric_limits<float>::max() * 0.8F);
Heightmap stamp = filled(1, 1, std::numeric_limits<float>::max() * 0.4F), one = filled(1, 1, 1);
std::vector<TerrainHeightTile> tiles{{"a", &a, 0, 0, 1, 1, false}, {"b", &b, 1, 0, 1, 1, false}};
TerrainStampSettings settings = setStamp(1, 0.5, 2, 1);
settings.operation = TerrainStampOperation::Add;
const auto beforeA = a.data(), beforeB = b.data();
CHECK(!applyTerrainStampMultiTile(tiles, stamp, settings, one, one).ok());
CHECK(a.data() == beforeA);
CHECK(b.data() == beforeB);
tiles[1].heightmap = &a;
CHECK(!applyTerrainStampMultiTile(tiles, stamp, settings, one, one).ok());
CHECK(a.data() == beforeA);
CHECK(b.data() == beforeB);
tiles[1] = {"b", &b, 1.25, 0, 1, 1, false};
CHECK(!applyTerrainStampMultiTile(tiles, stamp, settings, one, one).ok());
CHECK(a.data() == beforeA);
CHECK(b.data() == beforeB);
}
TEST_CASE("procgen.multitile.workspaceOwnsInputsAndPublishesReport") {
Heightmap source = filled(3, 3, 1), out = filled(3, 3, 0), stamp = filled(1, 1, 6), one = filled(1, 1, 1);
TerrainMultiTileWorkspace workspace;
REQUIRE(workspace.addTile("tile", source, 0, 0, 2, 2).ok());
source.data()[4] = 99;
REQUIRE(workspace.stamp(stamp, setStamp(1, 1, 2, 2), one, one).ok());
CHECK(workspace.getTileCount() == 1);
CHECK(workspace.getLastAffectedTiles() == 1);
CHECK(workspace.getLastMappingCount() == 1);
REQUIRE(workspace.copyTile("tile", out).ok());
CHECK(out.height(1, 1) == 6);
CHECK(workspace.getOperationCount() == 1);
CHECK(workspace.getAppliedCount() == 1);
REQUIRE(workspace.undo().ok());
CHECK(workspace.getAppliedCount() == 0);
REQUIRE(workspace.copyTile("tile", out).ok());
CHECK(out.height(1, 1) == 1);
REQUIRE(workspace.redo().ok());
REQUIRE(workspace.copyTile("tile", out).ok());
CHECK(out.height(1, 1) == 6);
CHECK(!workspace.addTile("tile", source, 2, 0, 2, 2).ok());
REQUIRE(workspace.copyTile("tile", out).ok());
CHECK(out.height(1, 1) == 6);
}
TEST_CASE("procgen.multitile.scriptOwnedTransaction") {
Heightmap west = filled(3, 3, 0), east = filled(3, 3, 0), out = filled(3, 3, 0);
Heightmap stamp = filled(1, 1, 3), one = filled(1, 1, 1);
ssq::VM vm(1024);
auto table = vm.addTable("eve");
exposeHeightmap(table);
vm.addFunc("west", [&]() { return &west; });
vm.addFunc("east", [&]() { return &east; });
vm.addFunc("stampRaster", [&]() { return &stamp; });
vm.addFunc("one", [&]() { return &one; });
vm.addFunc("out", [&]() { return &out; });
vm.run(vm.compileSource(R"(
local w=eve.TerrainMultiTileWorkspace();
assert(w.addTile("west",west(),0.0,0.0,2.0,2.0,false).ok);
assert(w.addTile("east",east(),2.0,0.0,2.0,2.0,false).ok);
local s=eve.TerrainStampSettings();s.setCenter(2.0,1.0);s.setSize(2.0,2.0);
assert(w.stamp(stampRaster(),s,3,one(),one(),false).ok);
assert(w.getTileCount()==2 && w.getLastAffectedTiles()==2 && w.getLastMappingCount()==2);
assert(w.copyTile("east",out()).ok && out().height(0,1)==3.0);
assert(w.getOperationCount()==1 && w.getAppliedCount()==1);
assert(w.undo().ok && w.getAppliedCount()==0);
assert(w.copyTile("east",out()).ok && out().height(0,1)==0.0);
assert(w.redo().ok && w.getAppliedCount()==1);
assert(w.copyTile("east",out()).ok && out().height(0,1)==3.0);
assert(!w.copyTile("missing",out()).ok);
)"));
CHECK(west.height(1, 1) == 0);
CHECK(east.height(0, 1) == 0);
}
TEST_CASE("procgen.terrainStitcher.matchesPcgSeamAndFailsAtomically") {
Heightmap south = filled(5, 5, 0), north = filled(5, 5, 1);
TerrainHeightTile a{"south", &south, 0, 0, 4, 4, false};
TerrainHeightTile b{"north", &north, 0, 4, 4, 4, false};
TerrainHeightStitchSettings settings;
settings.extraSeamSize = 1;
auto stitched = stitchTerrainHeightmaps(a, b, settings);
REQUIRE(stitched.ok());
CHECK(stitched.value() == 10);
for (int x = 0; x < 5; ++x) {
CHECK(south.height(x, 4) == 0.5F);
CHECK(north.height(x, 0) == 0.5F);
CHECK(south.height(x, 3) == 0);
CHECK(north.height(x, 1) == 1);
}
const auto beforeSouth = south.data(), beforeNorth = north.data();
b.originZ = 9;
CHECK(!stitchTerrainHeightmaps(a, b, settings).ok());
CHECK(south.data() == beforeSouth);
CHECK(north.data() == beforeNorth);
}
TEST_CASE("procgen.terrainStitcher.workspaceUndoAndScriptBinding") {
Heightmap low = filled(3, 3, 0), high = filled(3, 3, 1), output = filled(3, 3, 0);
TerrainMultiTileWorkspace workspace;
REQUIRE(workspace.addTile("west", low, 0, 0, 2, 2).ok());
REQUIRE(workspace.addTile("east", high, 2, 0, 2, 2).ok());
TerrainHeightStitchSettings settings;
REQUIRE(workspace.stitch("west", "east", settings).ok());
REQUIRE(workspace.copyTile("west", output).ok());
CHECK(output.height(2, 1) == 0.5F);
REQUIRE(workspace.undo().ok());
REQUIRE(workspace.copyTile("west", output).ok());
CHECK(output.height(2, 1) == 0);
REQUIRE(workspace.redo().ok());
ssq::VM vm(1024);
auto table = vm.addTable("eve");
exposeHeightmap(table);
vm.addFunc("low", [&]() { return &low; });
vm.addFunc("high", [&]() { return &high; });
vm.addFunc("output", [&]() { return &output; });
vm.run(vm.compileSource(R"(
local w=eve.TerrainMultiTileWorkspace();
assert(w.addTile("south",low(),0.0,0.0,2.0,2.0,false).ok);
assert(w.addTile("north",high(),0.0,2.0,2.0,2.0,false).ok);
local s=eve.TerrainHeightStitchSettings();s.extraSeamSize=1;s.maxDifference=1.0;
assert(w.stitch("south","north",s).ok);
assert(w.copyTile("south",output()).ok && output().height(1,2)==0.5);
assert(w.undo().ok && w.copyTile("south",output()).ok && output().height(1,2)==0.0);
)"));
}
Reference in new issue View Git Blame Copy Permalink