Mgvalleys: Add Dry Riverbeds

Lower water table where base humidity is low.
Alter heat and humidity to compensate for river humidity and altitude
chill.
Correct misuse of surface_max_y in generateTerrain.
Remove sand trails in the water at river mouths.
Remove river water below water_level.
Correct heat/humidity calculations where noises are less than zero.
Correct heightmap errors as much as possible.
Make humidity calculations more readable.
This commit is contained in:
Duane Robertson 2016-02-26 20:41:13 -06:00 committed by paramat
parent 158bd76e87
commit 6969dd4224

@ -399,8 +399,21 @@ void MapgenValleys::calculateNoise()
//mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f); //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
float heat_offset = 0.f;
float humidity_scale = 1.f;
// Altitude chill tends to reduce the average heat.
if (use_altitude_chill)
heat_offset = 5.f;
// River humidity tends to increase the humidity range.
if (humid_rivers) {
humidity_scale = 0.8f;
}
for (s32 index = 0; index < csize.X * csize.Z; index++) { for (s32 index = 0; index < csize.X * csize.Z; index++) {
noise_heat->result[index] += noise_heat_blend->result[index]; noise_heat->result[index] += noise_heat_blend->result[index] + heat_offset;
noise_humidity->result[index] *= humidity_scale;
noise_humidity->result[index] += noise_humidity_blend->result[index]; noise_humidity->result[index] += noise_humidity_blend->result[index];
} }
@ -481,9 +494,10 @@ float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
} }
// base - depth : height of the bottom of the river // base - depth : height of the bottom of the river
// water_level - 6 : don't make rivers below 6 nodes under the surface // water_level - 3 : don't make rivers below 3 nodes under the surface
// We use three because that's as low as the swamp biomes go.
// There is no logical equivalent to this using rangelim. // There is no logical equivalent to this using rangelim.
mount = MYMIN(MYMAX(base - depth, (float) (water_level - 6)), mount); mount = MYMIN(MYMAX(base - depth, (float)(water_level - 3)), mount);
// Slope has no influence on rivers. // Slope has no influence on rivers.
*tn->slope = 0.f; *tn->slope = 0.f;
@ -503,7 +517,7 @@ float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
for (s16 y = y_start; y <= y_start + 1000; y++) { for (s16 y = y_start; y <= y_start + 1000; y++) {
float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed); float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
if (fill * *tn->slope <= y - mount) { if (fill * *tn->slope < y - mount) {
mount = MYMAX(y - 1, mount); mount = MYMAX(y - 1, mount);
break; break;
} }
@ -552,6 +566,15 @@ float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
int MapgenValleys::generateTerrain() int MapgenValleys::generateTerrain()
{ {
// Raising this reduces the rate of evaporation.
static const float evaporation = 300.f;
// from the lua
static const float humidity_dropoff = 4.f;
// constant to convert altitude chill (compatible with lua) to heat
static const float alt_to_heat = 20.f;
// humidity reduction by altitude
static const float alt_to_humid = 10.f;
MapNode n_air(CONTENT_AIR); MapNode n_air(CONTENT_AIR);
MapNode n_river_water(c_river_water_source); MapNode n_river_water(c_river_water_source);
MapNode n_sand(c_sand); MapNode n_sand(c_sand);
@ -564,42 +587,56 @@ int MapgenValleys::generateTerrain()
for (s16 z = node_min.Z; z <= node_max.Z; z++) for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) { for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
s16 river_y = floor(noise_rivers->result[index_2d]); float river_y = noise_rivers->result[index_2d];
s16 surface_y = floor(noise_terrain_height->result[index_2d]); float surface_y = noise_terrain_height->result[index_2d];
float slope = noise_inter_valley_slope->result[index_2d]; float slope = noise_inter_valley_slope->result[index_2d];
float t_heat = noise_heat->result[index_2d];
heightmap[index_2d] = surface_y; heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
if (surface_y > surface_max_y) if (surface_y > surface_max_y)
surface_max_y = surface_y; surface_max_y = ceil(surface_y);
if (humid_rivers) {
// Derive heat from (base) altitude. This will be most correct
// at rivers, since other surface heights may vary below.
if (use_altitude_chill && (surface_y > 0.f || river_y > 0.f))
t_heat -= alt_to_heat * MYMAX(surface_y, river_y) / altitude_chill;
// If humidity is low or heat is high, lower the water table.
float delta = noise_humidity->result[index_2d] - 50.f;
if (delta < 0.f) {
float t_evap = (t_heat - 32.f) / evaporation;
river_y += delta * MYMAX(t_evap, 0.08f);
}
}
u32 index_3d = (z - node_min.Z) * zstride + (x - node_min.X); u32 index_3d = (z - node_min.Z) * zstride + (x - node_min.X);
u32 index_data = vm->m_area.index(x, node_min.Y - 1, z); u32 index_data = vm->m_area.index(x, node_min.Y - 1, z);
// Mapgens concern themselves with stone and water. // Mapgens concern themselves with stone and water.
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) { for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
float fill = 0.f;
fill = noise_inter_valley_fill->result[index_3d];
if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) { if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
bool river = (river_y > surface_y); float fill = noise_inter_valley_fill->result[index_3d];
float surface_delta = (float)y - surface_y;
bool river = y + 1 < river_y;
if (river && y == surface_y) { if (fabs(surface_delta) <= 0.5f && y > water_level && river) {
// river bottom // river bottom
vm->m_data[index_data] = n_sand; vm->m_data[index_data] = n_sand;
} else if (river && y <= surface_y) { } else if (slope * fill > surface_delta) {
// ground // ground
vm->m_data[index_data] = n_stone; vm->m_data[index_data] = n_stone;
} else if (river && y < river_y) { if (y > heightmap[index_2d])
// river heightmap[index_2d] = y;
vm->m_data[index_data] = n_river_water; if (y > surface_max_y)
} else if ((!river) && myround(fill * slope) >= y - surface_y) { surface_max_y = y;
// ground
vm->m_data[index_data] = n_stone;
heightmap[index_2d] = surface_max_y = y;
} else if (y <= water_level) { } else if (y <= water_level) {
// sea // sea
vm->m_data[index_data] = n_water; vm->m_data[index_data] = n_water;
} else if (river) {
// river
vm->m_data[index_data] = n_river_water;
} else { } else {
vm->m_data[index_data] = n_air; vm->m_data[index_data] = n_air;
} }
@ -609,18 +646,51 @@ int MapgenValleys::generateTerrain()
index_3d += ystride; index_3d += ystride;
} }
// Although the original valleys adjusts humidity by distance // This happens if we're generating a chunk that doesn't
// from seawater, this causes problems with the default biomes. // contain the terrain surface, in which case, we need
// Adjust only by freshwater proximity. // to set heightmap to a value outside of the chunk,
const float humidity_offset = 0.8f; // derived by testing // to avoid confusing lua mods that use heightmap.
if (humid_rivers) if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
noise_humidity->result[index_2d] *= (1 + pow(0.5f, MYMAX((surface_max_y s16 surface_y_int = myround(surface_y);
- noise_rivers->result[index_2d]) / 3.f, 0.f))) * humidity_offset; if (surface_y_int > node_max.Y + 1 || surface_y_int < node_min.Y - 1) {
// If surface_y is outside the chunk, it's good enough.
heightmap[index_2d] = surface_y_int;
} else {
// If the ground is outside of this chunk, but surface_y
// is within the chunk, give a value outside.
heightmap[index_2d] = node_min.Y - 2;
}
}
// Assign the heat adjusted by altitude. if (humid_rivers) {
if (use_altitude_chill && surface_max_y > 0) // Use base ground (water table) in a riverbed, to
noise_heat->result[index_2d] *= // avoid an unnatural rise in humidity.
pow(0.5f, (surface_max_y - altitude_chill / 3.f) / altitude_chill); float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
float humid = noise_humidity->result[index_2d];
float water_depth = (t_alt - river_y) / humidity_dropoff;
humid *= 1.f + pow(0.5f, MYMAX(water_depth, 1.f));
// Reduce humidity with altitude (ignoring riverbeds).
// This is similar to the lua version's seawater adjustment,
// but doesn't increase the base humidity, which causes
// problems with the default biomes.
if (t_alt > 0.f)
humid -= alt_to_humid * t_alt / altitude_chill;
noise_humidity->result[index_2d] = humid;
}
// Assign the heat adjusted by any changed altitudes.
// The altitude will change about half the time.
if (use_altitude_chill) {
// ground height ignoring riverbeds
float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
if (humid_rivers && heightmap[index_2d] == (s16)myround(surface_y))
// The altitude hasn't changed. Use the first result.
noise_heat->result[index_2d] = t_heat;
else if (t_alt > 0.f)
noise_heat->result[index_2d] -= alt_to_heat * t_alt / altitude_chill;
}
} }
return surface_max_y; return surface_max_y;
@ -645,7 +715,7 @@ MgStoneType MapgenValleys::generateBiomes(float *heat_map, float *humidity_map)
// generated mapchunk or if not, a node of overgenerated base terrain. // generated mapchunk or if not, a node of overgenerated base terrain.
content_t c_above = vm->m_data[vi + em.X].getContent(); content_t c_above = vm->m_data[vi + em.X].getContent();
bool air_above = c_above == CONTENT_AIR; bool air_above = c_above == CONTENT_AIR;
bool water_above = (c_above == c_water_source); bool water_above = (c_above == c_water_source || c_above == c_river_water_source);
// If there is air or water above enable top/filler placement, otherwise force // If there is air or water above enable top/filler placement, otherwise force
// nplaced to stone level by setting a number exceeding any possible filler depth. // nplaced to stone level by setting a number exceeding any possible filler depth.
@ -714,7 +784,7 @@ MgStoneType MapgenValleys::generateBiomes(float *heat_map, float *humidity_map)
water_above = true; water_above = true;
} else if (c == c_river_water_source) { } else if (c == c_river_water_source) {
vm->m_data[vi] = MapNode(biome->c_river_water); vm->m_data[vi] = MapNode(biome->c_river_water);
nplaced = U16_MAX; // Sand was already placed under rivers. nplaced = depth_top; // Enable filler placement for next surface
air_above = false; air_above = false;
water_above = true; water_above = true;
} else if (c == CONTENT_AIR) { } else if (c == CONTENT_AIR) {