195 lines
6.0 KiB
C++
195 lines
6.0 KiB
C++
#include "zeroerr/assert.h"
|
|
#include "zeroerr/unittest.h"
|
|
|
|
#include <cmath>
|
|
|
|
#include "procgen/heightmap/Heightmap.h"
|
|
#include "snow/Snow.h"
|
|
#include "snow/SnowField.h"
|
|
|
|
using eve::snow::SnowField;
|
|
|
|
TEST_CASE("SnowField.basicGrid") {
|
|
SnowField f(8, 6);
|
|
CHECK_EQ(f.getWidth(), 8);
|
|
CHECK_EQ(f.getHeight(), 6);
|
|
CHECK_EQ(f.height(3, 2), 0.f);
|
|
CHECK_EQ(f.height(-1, 0), 0.f); // out-of-bounds reads 0
|
|
|
|
f.setHeight(3, 2, 0.8f);
|
|
CHECK_EQ(f.height(3, 2), 0.8f);
|
|
f.fill(0.5f);
|
|
CHECK_EQ(f.height(0, 0), 0.5f);
|
|
|
|
f.setHeight(0, 0, 2.f); // clamped to [0,1]
|
|
CHECK_EQ(f.height(0, 0), 1.f);
|
|
f.setHeight(0, 0, -0.5f);
|
|
CHECK_EQ(f.height(0, 0), 0.f);
|
|
f.setHeight(99, 99, 0.7f); // out-of-bounds write is a no-op
|
|
|
|
f.resize(4, 4);
|
|
CHECK_EQ(f.getWidth(), 4);
|
|
CHECK_EQ(f.getHeight(), 4);
|
|
CHECK(f.isDirty());
|
|
}
|
|
|
|
TEST_CASE("SnowField.footprintDepressesAndRaisesRim") {
|
|
SnowField f(16, 16);
|
|
f.fill(0.8f);
|
|
f.clearDirty();
|
|
|
|
f.stampFootprint(8.f, 8.f, 1.f, 0.f, 3.f, 0.5f);
|
|
CHECK(f.isDirty());
|
|
|
|
CHECK(f.height(8, 8) < 0.4f); // center pressed down
|
|
CHECK(f.height(10, 8) < 0.75f); // inner footprint lowered
|
|
CHECK(f.height(8, 10) == 0.8f); // narrower across: untouched
|
|
CHECK(f.height(11, 8) > 0.85f); // pushed-up rim at the edge
|
|
CHECK(f.height(2, 2) == 0.8f); // far away untouched
|
|
|
|
f.clearDirty();
|
|
CHECK(!f.isDirty());
|
|
}
|
|
|
|
TEST_CASE("SnowField.footprintFollowsTravelDirection") {
|
|
SnowField f(16, 16);
|
|
f.fill(0.8f);
|
|
f.stampFootprint(8.f, 8.f, 0.f, 1.f, 3.f, 0.5f);
|
|
|
|
CHECK(f.height(8, 10) < 0.75f); // elongated along +Z
|
|
CHECK(f.height(10, 8) == 0.8f); // across direction untouched
|
|
}
|
|
|
|
TEST_CASE("SnowField.impactCraterBowlAndRim") {
|
|
SnowField f(20, 20);
|
|
f.fill(0.8f);
|
|
f.stampImpact(10.f, 10.f, 4.f, 0.6f);
|
|
|
|
CHECK(f.height(10, 10) < 0.21f); // deep bowl center
|
|
CHECK(f.height(13, 10) < 0.78f); // shallow bowl near the edge
|
|
CHECK(f.height(14, 10) > 0.85f); // raised ejecta ring outside the bowl
|
|
CHECK(f.height(16, 10) == 0.8f); // outside the rim band
|
|
|
|
// Ejecta is intentionally lumpy: ring heights vary per cell instead of
|
|
// forming a perfect smooth ring.
|
|
float lo = 1.f, hi = 0.f;
|
|
for (int z = 5; z <= 15; ++z) {
|
|
for (int x = 5; x <= 15; ++x) {
|
|
const float dx = float(x) - 10.f;
|
|
const float dz = float(z) - 10.f;
|
|
const float n = std::sqrt(dx * dx + dz * dz) / 4.f;
|
|
if (n < 0.95f || n > 1.4f) continue;
|
|
lo = std::min(lo, f.height(x, z));
|
|
hi = std::max(hi, f.height(x, z));
|
|
}
|
|
}
|
|
CHECK(hi - lo > 0.05f);
|
|
}
|
|
|
|
TEST_CASE("SnowField.snowfallRecovery") {
|
|
SnowField f(4, 4);
|
|
f.fill(0.5f);
|
|
f.clearDirty();
|
|
|
|
f.addSnowfall(0.2f);
|
|
CHECK(f.isDirty());
|
|
CHECK(std::fabs(f.height(0, 0) - 0.7f) < 1e-5f);
|
|
|
|
f.addSnowfall(0.5f);
|
|
CHECK_EQ(f.height(0, 0), 1.f); // clamped at full cover
|
|
f.addSnowfall(-1.f); // negative amounts are ignored
|
|
CHECK_EQ(f.height(0, 0), 1.f);
|
|
}
|
|
|
|
TEST_CASE("SnowField.heightTexture") {
|
|
SnowField f(3, 2);
|
|
f.fill(1.f);
|
|
std::vector<uint8_t> rgba = f.toHeightRGBA();
|
|
CHECK_EQ(int(rgba.size()), 3 * 2 * 4);
|
|
CHECK_EQ(int(rgba[0]), 255); // R = height
|
|
CHECK_EQ(int(rgba[12]), 255); // R of the last cell
|
|
CHECK_EQ(int(rgba[1]), 0); // G/B stay 0 so albedo stays clean
|
|
CHECK_EQ(int(rgba[2]), 0);
|
|
|
|
f.setHeight(0, 0, 0.5f);
|
|
rgba = f.toHeightRGBA();
|
|
CHECK(int(rgba[0]) >= 126);
|
|
CHECK(int(rgba[0]) <= 130);
|
|
CHECK_EQ(int(rgba[3]), 255); // alpha always opaque
|
|
}
|
|
|
|
TEST_CASE("SnowField.albedoBlendsSnowToGround") {
|
|
SnowField f(4, 4);
|
|
f.fill(0.f);
|
|
std::vector<uint8_t> rgba = f.toAlbedoRGBA();
|
|
CHECK(int(rgba[0]) >= 85); // dark soil
|
|
CHECK(int(rgba[0]) <= 100);
|
|
CHECK(int(rgba[1]) >= 70);
|
|
CHECK(int(rgba[1]) <= 85);
|
|
CHECK(int(rgba[2]) >= 55);
|
|
CHECK(int(rgba[2]) <= 68);
|
|
|
|
f.fill(1.f);
|
|
rgba = f.toAlbedoRGBA();
|
|
CHECK(int(rgba[0]) >= 230); // cool white snow
|
|
CHECK(int(rgba[0]) <= 245);
|
|
CHECK(int(rgba[3]) == 255);
|
|
|
|
// Albedo is a color ramp, not a copy of the height channel: at s = 0.25 the
|
|
// red channel (packed snow) must differ from the height texture's
|
|
// red (64).
|
|
f.fill(0.25f);
|
|
const int albedoR = int(f.toAlbedoRGBA()[0]);
|
|
const int heightR = int(f.toHeightRGBA()[0]);
|
|
CHECK(std::abs(albedoR - heightR) > 20);
|
|
}
|
|
|
|
TEST_CASE("SnowField.normalMapFromGradient") {
|
|
SnowField f(16, 16);
|
|
f.fill(0.5f);
|
|
std::vector<uint8_t> flat = f.toNormalRGBA();
|
|
CHECK(int(flat[0]) >= 126); // flat = 128,128,255
|
|
CHECK(int(flat[0]) <= 130);
|
|
CHECK(int(flat[1]) >= 126);
|
|
CHECK(int(flat[1]) <= 130);
|
|
CHECK(int(flat[2]) >= 252);
|
|
|
|
// Linearly rising snow toward +X tilts the normal away from +U.
|
|
for (int z = 0; z < 16; ++z) {
|
|
for (int x = 0; x < 16; ++x) {
|
|
f.setHeight(x, z, 0.4f + 0.05f * float(x));
|
|
}
|
|
}
|
|
std::vector<uint8_t> slope = f.toNormalRGBA();
|
|
const size_t i = (8 * 16 + 8) * 4;
|
|
CHECK(int(slope[i + 0]) < 120); // nx < 0 -> R below mid gray
|
|
CHECK(int(slope[i + 1]) >= 126);
|
|
CHECK(int(slope[i + 1]) <= 130);
|
|
CHECK(int(slope[i + 2]) >= 245);
|
|
}
|
|
|
|
TEST_CASE("SnowField.applyToHeightmapAddsSnow") {
|
|
eve::procgen::Heightmap terrain(8, 8);
|
|
for (int y = 0; y < 8; ++y) {
|
|
for (int x = 0; x < 8; ++x) {
|
|
terrain.setHeight(x, y, 0.5f);
|
|
}
|
|
}
|
|
|
|
SnowField f(8, 8);
|
|
f.fill(0.5f);
|
|
eve::procgen::Heightmap out;
|
|
eve::snow::applySnowToHeightmap(f, terrain, out, 0.2f);
|
|
CHECK_EQ(out.getWidth(), 8);
|
|
CHECK(std::fabs(out.height(3, 3) - 0.6f) < 1e-5f); // 0.5 + 0.5 * 0.2
|
|
|
|
f.setHeight(2, 2, 0.f);
|
|
eve::snow::applySnowToHeightmap(f, terrain, out, 0.2f);
|
|
CHECK(std::fabs(out.height(2, 2) - 0.5f) < 1e-5f); // bare ground
|
|
|
|
SnowField small(4, 4);
|
|
small.fill(1.f);
|
|
eve::snow::applySnowToHeightmap(small, terrain, out, 0.2f);
|
|
CHECK(std::fabs(out.height(6, 6) - 0.5f) < 1e-5f); // outside field: terrain only
|
|
}
|