BRNSystems/minetest
1
0
Fork 0
forked from Mirrorlandia_minetest/minetest
Code Pull Requests1 Activity

Valleys mapgen code rewrite ()

Browse Source 
Shorter, simpler, clearer and more consistent with other mapgens,
while preserving functionality.
Base terrain shape is unchanged.
With the 'vary river depth' option disabled, river surface level
is unchanged.
Behaviour of the 4 heat/humidity/river depth options is very
slightly changed due to bugfixes and code cleanup (the mapgen is
'unstable').
Apply heat and humidity gradients above water_level instead of
above y = 0.
This commit is contained in:
Paramat
2019-03-14 00:27:16 +00:00
committed by GitHub
parent e22a69d61a
commit aafbdd442f
2 changed files with 122 additions and 257 deletions

358
src/mapgen/mapgen_valleys.cpp

@ -1,7 +1,7 @@
/* /*
Minetest Minetest
Copyright (C) 2016-2018 Duane Robertson <duane@duanerobertson.com> Copyright (C) 2016-2019 Duane Robertson <duane@duanerobertson.com>
Copyright (C) 2016-2018 paramat Copyright (C) 2016-2019 paramat
Based on Valleys Mapgen by Gael de Sailly Based on Valleys Mapgen by Gael de Sailly
(https://forum.minetest.net/viewtopic.php?f=9&t=11430) (https://forum.minetest.net/viewtopic.php?f=9&t=11430)
@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#include "mapgen.h" #include "mapgen.h"
#include "voxel.h" #include "voxel.h"
#include "noise.h" #include "noise.h"
@ -53,9 +54,6 @@ FlagDesc flagdesc_mapgen_valleys[] = {
}; };
////////////////////////////////////////////////////////////////////////////////
MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params,
EmergeManager *emerge) EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge) : MapgenBasic(mapgenid, params, emerge)
@ -63,8 +61,6 @@ MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params,
// NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal // NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal
m_bgen = (BiomeGenOriginal *)biomegen; m_bgen = (BiomeGenOriginal *)biomegen;
BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
spflags = params->spflags; spflags = params->spflags;
altitude_chill = params->altitude_chill; altitude_chill = params->altitude_chill;
river_depth_bed = params->river_depth + 1.0f; river_depth_bed = params->river_depth + 1.0f;
@ -95,8 +91,6 @@ MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params,
MapgenBasic::np_cave1 = params->np_cave1; MapgenBasic::np_cave1 = params->np_cave1;
MapgenBasic::np_cave2 = params->np_cave2; MapgenBasic::np_cave2 = params->np_cave2;
MapgenBasic::np_cavern = params->np_cavern; MapgenBasic::np_cavern = params->np_cavern;
humidity_adjust = bp->np_humidity.offset - 50.0f;
} }
@ -185,9 +179,6 @@ void MapgenValleysParams::writeParams(Settings *settings) const
} }
////////////////////////////////////////////////////////////////////////////////
void MapgenValleys::makeChunk(BlockMakeData *data) void MapgenValleys::makeChunk(BlockMakeData *data)
{ {
// Pre-conditions // Pre-conditions
@ -220,19 +211,16 @@ void MapgenValleys::makeChunk(BlockMakeData *data)
// biome-related noises. // biome-related noises.
m_bgen->calcBiomeNoise(node_min); m_bgen->calcBiomeNoise(node_min);
// Generate noise maps and base terrain height. // Generate terrain
// Modify heat and humidity maps.
calculateNoise();
// Generate base terrain with initial heightmaps
s16 stone_surface_max_y = generateTerrain(); s16 stone_surface_max_y = generateTerrain();
// Recalculate heightmap // Create heightmap
updateHeightmap(node_min, node_max); updateHeightmap(node_min, node_max);
// Place biome-specific nodes and build biomemap // Place biome-specific nodes and build biomemap
if (flags & MG_BIOMES) if (flags & MG_BIOMES) {
generateBiomes(); generateBiomes();
}
// Generate tunnels, caverns and large randomwalk caves // Generate tunnels, caverns and large randomwalk caves
if (flags & MG_CAVES) { if (flags & MG_CAVES) {
@ -281,244 +269,151 @@ void MapgenValleys::makeChunk(BlockMakeData *data)
} }
void MapgenValleys::calculateNoise()
{
int x = node_min.X;
int y = node_min.Y - 1;
int z = node_min.Z;
noise_inter_valley_slope->perlinMap2D(x, z);
noise_rivers->perlinMap2D(x, z);
noise_terrain_height->perlinMap2D(x, z);
noise_valley_depth->perlinMap2D(x, z);
noise_valley_profile->perlinMap2D(x, z);
noise_inter_valley_fill->perlinMap3D(x, y, z);
float heat_offset = 0.0f;
float humidity_scale = 1.0f;
// Altitude chill tends to reduce the average heat.
if (spflags & MGVALLEYS_ALT_CHILL)
heat_offset = 5.0f;
// River humidity tends to increase the humidity range.
if (spflags & MGVALLEYS_HUMID_RIVERS)
humidity_scale = 0.8f;
for (s32 index = 0; index < csize.X * csize.Z; index++) {
m_bgen->heatmap[index] += heat_offset;
m_bgen->humidmap[index] *= humidity_scale;
}
TerrainNoise tn;
u32 index = 0;
for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++)
for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) {
// The parameters that we actually need to generate terrain are passed
// by address (and the return value).
tn.terrain_height = noise_terrain_height->result[index];
// River noise is replaced with base terrain, which is basically the
// height of the water table.
tn.rivers = &noise_rivers->result[index];
// Valley depth noise is replaced with the valley number that represents
// the height of terrain over rivers and is used to determine how close
// a river is for humidity calculation.
tn.valley = &noise_valley_depth->result[index];
tn.valley_profile = noise_valley_profile->result[index];
// Slope noise is replaced by the calculated slope which is used to get
// terrain height in the slow method, to create sharper mountains.
tn.slope = &noise_inter_valley_slope->result[index];
tn.inter_valley_fill = noise_inter_valley_fill->result[index];
// This is the actual terrain height.
float mount = terrainLevelFromNoise(&tn);
noise_terrain_height->result[index] = mount;
}
}
float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
{
// The square function changes the behaviour of this noise: very often
// small, and sometimes very high.
float valley_d = MYSQUARE(*tn->valley);
// valley_d is here because terrain is generally higher where valleys are
// deep (mountains). base represents the height of the rivers, most of the
// surface is above.
float base = tn->terrain_height + valley_d;
// "river" represents the distance from the river
float river = std::fabs(*tn->rivers) - river_size_factor;
// Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
// "valley" represents the height of the terrain, from the rivers.
float tv = std::fmax(river / tn->valley_profile, 0.0f);
*tn->valley = valley_d * (1.0f - std::exp(-MYSQUARE(tv)));
// Approximate height of the terrain at this point
float mount = base + *tn->valley;
*tn->slope *= *tn->valley;
// Base ground is returned as rivers since it's basically the water table.
*tn->rivers = base;
// Rivers are placed where "river" is negative, so where the original noise
// value is close to zero.
if (river < 0.0f) {
// Use the the function -sqrt(1-x^2) which models a circle
float tr = river / river_size_factor + 1.0f;
float depth = (river_depth_bed *
std::sqrt(std::fmax(0.0f, 1.0f - MYSQUARE(tr))));
// base - depth : height of the bottom of the river
// 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.
mount =
std::fmin(std::fmax(base - depth, (float)(water_level - 3)), mount);
// Slope has no influence on rivers
*tn->slope = 0.0f;
}
return mount;
}
// This avoids duplicating the code in terrainLevelFromNoise, adding only the
// final step of terrain generation without a noise map.
float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
{
float mount = terrainLevelFromNoise(tn);
float result = mount;
s16 y_start = myround(mount);
float fill =
NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y_start, tn->z, seed);
bool is_ground = fill * *tn->slope >= y_start - mount;
s16 search_direction = is_ground ? 1 : -1;
for (s16 i = 1; i <= 1000; i++) {
s16 y = y_start + i * search_direction;
fill =
NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
bool was_ground = is_ground;
is_ground = fill * *tn->slope >= y - mount;
if (is_ground)
result = y;
if (is_ground != was_ground)
break;
}
return result;
}
int MapgenValleys::getSpawnLevelAtPoint(v2s16 p) int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
{ {
// Check if in a river // Check if in a river channel
float rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed); float n_rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
if (std::fabs(rivers) < river_size_factor) if (std::fabs(n_rivers) <= river_size_factor)
return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point // Unsuitable spawn point
return MAX_MAP_GENERATION_LIMIT;
s16 level_at_point = terrainLevelAtPoint(p.X, p.Y); float n_slope = NoisePerlin2D(&noise_inter_valley_slope->np, p.X, p.Y, seed);
if (level_at_point <= water_level || float n_terrain_height = NoisePerlin2D(&noise_terrain_height->np, p.X, p.Y, seed);
level_at_point > water_level + 16) float n_valley = NoisePerlin2D(&noise_valley_depth->np, p.X, p.Y, seed);
return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point float n_valley_profile = NoisePerlin2D(&noise_valley_profile->np, p.X, p.Y, seed);
// +1 to account for biome dust that can be 1 node deep float valley_d = n_valley * n_valley;
return level_at_point + 1; float base = n_terrain_height + valley_d;
float river = std::fabs(n_rivers) - river_size_factor;
float tv = std::fmax(river / n_valley_profile, 0.0f);
float valley_h = valley_d * (1.0f - std::exp(-tv * tv));
float surface_y = base + valley_h;
float slope = n_slope * valley_h;
float river_y = base - 1.0f;
// Raising the maximum spawn level above 'water_level + 16' is necessary for custom
// parameters that set average terrain level much higher than water_level.
s16 max_spawn_y = std::fmax(
noise_terrain_height->np.offset +
noise_valley_depth->np.offset * noise_valley_depth->np.offset,
water_level + 16);
// Starting spawn search at max_spawn_y + 128 ensures 128 nodes of open
// space above spawn position. Avoids spawning in possibly sealed voids.
for (s16 y = max_spawn_y + 128; y >= water_level; y--) {
float n_fill = NoisePerlin3D(&noise_inter_valley_fill->np, p.X, y, p.Y, seed);
float surface_delta = (float)y - surface_y;
float density = slope * n_fill - surface_delta;
if (density > 0.0f) { // If solid
// Sometimes surface level is below river water level in places that are not
// river channels.
if (y < water_level || y > max_spawn_y || y < (s16)river_y)
// Unsuitable spawn point
return MAX_MAP_GENERATION_LIMIT;
// y + 2 because y is surface and due to biome 'dust' nodes.
return y + 2;
} }
}
// Unsuitable spawn position, no ground found
float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z) return MAX_MAP_GENERATION_LIMIT;
{
TerrainNoise tn;
float rivers = NoisePerlin2D(&noise_rivers->np, x, z, seed);
float valley = NoisePerlin2D(&noise_valley_depth->np, x, z, seed);
float inter_valley_slope =
NoisePerlin2D(&noise_inter_valley_slope->np, x, z, seed);
tn.x = x;
tn.z = z;
tn.terrain_height = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
tn.rivers = &rivers;
tn.valley = &valley;
tn.valley_profile = NoisePerlin2D(&noise_valley_profile->np, x, z, seed);
tn.slope = &inter_valley_slope;
tn.inter_valley_fill = 0.0f;
return adjustedTerrainLevelFromNoise(&tn);
} }
int MapgenValleys::generateTerrain() int MapgenValleys::generateTerrain()
{ {
// Raising this reduces the rate of evaporation
static const float evaporation = 300.0f;
static const float humidity_dropoff = 4.0f;
// Constant to convert altitude chill to heat
static const float alt_to_heat = 20.0f;
// Humidity reduction by altitude
static const float alt_to_humid = 10.0f;
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_stone(c_stone); MapNode n_stone(c_stone);
MapNode n_water(c_water_source); MapNode n_water(c_water_source);
noise_inter_valley_slope->perlinMap2D(node_min.X, node_min.Z);
noise_rivers->perlinMap2D(node_min.X, node_min.Z);
noise_terrain_height->perlinMap2D(node_min.X, node_min.Z);
noise_valley_depth->perlinMap2D(node_min.X, node_min.Z);
noise_valley_profile->perlinMap2D(node_min.X, node_min.Z);
noise_inter_valley_fill->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
const v3s16 &em = vm->m_area.getExtent(); const v3s16 &em = vm->m_area.getExtent();
s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT; s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
u32 index_2d = 0; u32 index_2d = 0;
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++) {
float river_y = noise_rivers->result[index_2d]; float n_slope = noise_inter_valley_slope->result[index_2d];
float surface_y = noise_terrain_height->result[index_2d]; float n_rivers = noise_rivers->result[index_2d];
float slope = noise_inter_valley_slope->result[index_2d]; float n_terrain_height = noise_terrain_height->result[index_2d];
float t_heat = m_bgen->heatmap[index_2d]; float n_valley = noise_valley_depth->result[index_2d];
float n_valley_profile = noise_valley_profile->result[index_2d];
heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT; float valley_d = n_valley * n_valley;
// 'base' represents the level of the river banks
float base = n_terrain_height + valley_d;
// 'river' represents the distance from the river edge
float river = std::fabs(n_rivers) - river_size_factor;
// Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
// 'valley_h' represents the height of the terrain, from the rivers.
float tv = std::fmax(river / n_valley_profile, 0.0f);
float valley_h = valley_d * (1.0f - std::exp(-tv * tv));
// Approximate height of the terrain
float surface_y = base + valley_h;
float slope = n_slope * valley_h;
// River water surface is 1 node below river banks
float river_y = base - 1.0f;
if (surface_y > surface_max_y) // Rivers are placed where 'river' is negative
surface_max_y = std::ceil(surface_y); if (river < 0.0f) {
// Use the the function -sqrt(1-x^2) which models a circle
float tr = river / river_size_factor + 1.0f;
float depth = (river_depth_bed *
std::sqrt(std::fmax(0.0f, 1.0f - tr * tr)));
// There is no logical equivalent to this using rangelim
surface_y = std::fmin(
std::fmax(base - depth, (float)(water_level - 3)),
surface_y);
slope = 0.0f;
}
// Optionally vary river depth according to heat and humidity // Optionally vary river depth according to heat and humidity
if (spflags & MGVALLEYS_VARY_RIVER_DEPTH) { if (spflags & MGVALLEYS_VARY_RIVER_DEPTH) {
float heat = ((spflags & MGVALLEYS_ALT_CHILL) && float t_heat = m_bgen->heatmap[index_2d];
(surface_y > 0.0f || river_y > 0.0f)) ? float heat = (spflags & MGVALLEYS_ALT_CHILL) ?
t_heat - alt_to_heat * // Match heat value calculated below in
std::fmax(surface_y, river_y) / altitude_chill : // 'Optionally decrease heat with altitude'.
// In rivers, 'ground height ignoring riverbeds' is 'base'.
// As this only affects river water we can assume y > water_level.
t_heat + 5.0f - (base - water_level) * 20.0f / altitude_chill :
t_heat; t_heat;
float delta = m_bgen->humidmap[index_2d] - 50.0f; float delta = m_bgen->humidmap[index_2d] - 50.0f;
if (delta < 0.0f) { if (delta < 0.0f) {
float t_evap = (heat - 32.0f) / evaporation; float t_evap = (heat - 32.0f) / 300.0f;
river_y += delta * std::fmax(t_evap, 0.08f); river_y += delta * std::fmax(t_evap, 0.08f);
} }
} }
// Highest solid node in column
s16 column_max_y = surface_y;
u32 index_3d = (z - node_min.Z) * zstride_1u1d + (x - node_min.X); u32 index_3d = (z - node_min.Z) * zstride_1u1d + (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);
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++) {
if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) { if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
float fill = noise_inter_valley_fill->result[index_3d]; float n_fill = noise_inter_valley_fill->result[index_3d];
float surface_delta = (float)y - surface_y; float surface_delta = (float)y - surface_y;
bool river = y < river_y - 1; // Density = density noise + density gradient
float density = slope * n_fill - surface_delta;
if (slope * fill > surface_delta) { if (density > 0.0f) {
vm->m_data[index_data] = n_stone; // Stone vm->m_data[index_data] = n_stone; // Stone
if (y > heightmap[index_2d])
heightmap[index_2d] = y;
if (y > surface_max_y) if (y > surface_max_y)
surface_max_y = y; surface_max_y = y;
if (y > column_max_y)
column_max_y = y;
} else if (y <= water_level) { } else if (y <= water_level) {
vm->m_data[index_data] = n_water; // Water vm->m_data[index_data] = n_water; // Water
} else if (river) { } else if (y <= (s16)river_y) {
vm->m_data[index_data] = n_river_water; // River water vm->m_data[index_data] = n_river_water; // River water
} else { } else {
vm->m_data[index_data] = n_air; // Air vm->m_data[index_data] = n_air; // Air
@ -529,26 +424,13 @@ int MapgenValleys::generateTerrain()
index_3d += ystride; index_3d += ystride;
} }
if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
s16 surface_y_int = myround(surface_y);
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;
}
}
// Optionally increase humidity around rivers // Optionally increase humidity around rivers
if (spflags & MGVALLEYS_HUMID_RIVERS) { if (spflags & MGVALLEYS_HUMID_RIVERS) {
// Compensate to avoid increasing average humidity
m_bgen->humidmap[index_2d] *= 0.8f;
// Ground height ignoring riverbeds // Ground height ignoring riverbeds
float t_alt = std::fmax(noise_rivers->result[index_2d], float t_alt = std::fmax(base, (float)column_max_y);
(float)heightmap[index_2d]); float water_depth = (t_alt - base) / 4.0f;
float water_depth = (t_alt - river_y) / humidity_dropoff;
m_bgen->humidmap[index_2d] *= m_bgen->humidmap[index_2d] *=
1.0f + std::pow(0.5f, std::fmax(water_depth, 1.0f)); 1.0f + std::pow(0.5f, std::fmax(water_depth, 1.0f));
} }
@ -556,21 +438,23 @@ int MapgenValleys::generateTerrain()
// Optionally decrease humidity with altitude // Optionally decrease humidity with altitude
if (spflags & MGVALLEYS_ALT_DRY) { if (spflags & MGVALLEYS_ALT_DRY) {
// Ground height ignoring riverbeds // Ground height ignoring riverbeds
float t_alt = std::fmax(noise_rivers->result[index_2d], float t_alt = std::fmax(base, (float)column_max_y);
(float)heightmap[index_2d]); // Only decrease above water_level
if (t_alt > 0.0f) if (t_alt > water_level)
m_bgen->humidmap[index_2d] -= m_bgen->humidmap[index_2d] -=
alt_to_humid * t_alt / altitude_chill; (t_alt - water_level) * 10.0f / altitude_chill;
} }
// Optionally decrease heat with altitude // Optionally decrease heat with altitude
if (spflags & MGVALLEYS_ALT_CHILL) { if (spflags & MGVALLEYS_ALT_CHILL) {
// Compensate to avoid reducing the average heat
m_bgen->heatmap[index_2d] += 5.0f;
// Ground height ignoring riverbeds // Ground height ignoring riverbeds
float t_alt = std::fmax(noise_rivers->result[index_2d], float t_alt = std::fmax(base, (float)column_max_y);
(float)heightmap[index_2d]); // Only decrease above water_level
if (t_alt > 0.0f) if (t_alt > water_level)
m_bgen->heatmap[index_2d] -= m_bgen->heatmap[index_2d] -=
alt_to_heat * t_alt / altitude_chill; (t_alt - water_level) * 20.0f / altitude_chill;
} }
} }

27
src/mapgen/mapgen_valleys.h

@ -1,11 +1,11 @@
/* /*
Minetest Minetest
Copyright (C) 2016-2018 Duane Robertson <duane@duanerobertson.com> Copyright (C) 2016-2019 Duane Robertson <duane@duanerobertson.com>
Copyright (C) 2016-2018 paramat Copyright (C) 2016-2019 paramat
Based on Valleys Mapgen by Gael de Sailly Based on Valleys Mapgen by Gael de Sailly
(https://forum.minetest.net/viewtopic.php?f=9&t=11430) (https://forum.minetest.net/viewtopic.php?f=9&t=11430)
and mapgen_v7 by kwolekr and paramat. and mapgen_v7, mapgen_flat by kwolekr and paramat.
Licensing changed by permission of Gael de Sailly. Licensing changed by permission of Gael de Sailly.
@ -24,20 +24,16 @@ with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#pragma once #pragma once
#include "mapgen.h" #include "mapgen.h"
/////////////////// Mapgen Valleys flags
#define MGVALLEYS_ALT_CHILL 0x01 #define MGVALLEYS_ALT_CHILL 0x01
#define MGVALLEYS_HUMID_RIVERS 0x02 #define MGVALLEYS_HUMID_RIVERS 0x02
#define MGVALLEYS_VARY_RIVER_DEPTH 0x04 #define MGVALLEYS_VARY_RIVER_DEPTH 0x04
#define MGVALLEYS_ALT_DRY 0x08 #define MGVALLEYS_ALT_DRY 0x08
// Feed only one variable into these
#define MYSQUARE(x) (x) * (x)
#define MYCUBE(x) (x) * (x) * (x)
class BiomeManager; class BiomeManager;
class BiomeGenOriginal; class BiomeGenOriginal;
@ -79,16 +75,6 @@ struct MapgenValleysParams : public MapgenParams {
void writeParams(Settings *settings) const; void writeParams(Settings *settings) const;
}; };
struct TerrainNoise {
s16 x;
s16 z;
float terrain_height;
float *rivers;
float *valley;
float valley_profile;
float *slope;
float inter_valley_fill;
};
class MapgenValleys : public MapgenBasic { class MapgenValleys : public MapgenBasic {
public: public:
@ -106,7 +92,6 @@ private:
BiomeGenOriginal *m_bgen; BiomeGenOriginal *m_bgen;
float altitude_chill; float altitude_chill;
float humidity_adjust;
float river_depth_bed; float river_depth_bed;
float river_size_factor; float river_size_factor;
@ -121,9 +106,5 @@ private:
Noise *noise_valley_depth; Noise *noise_valley_depth;
Noise *noise_valley_profile; Noise *noise_valley_profile;
float terrainLevelAtPoint(s16 x, s16 z);
void calculateNoise();
virtual int generateTerrain(); virtual int generateTerrain();
float terrainLevelFromNoise(TerrainNoise *tn);
float adjustedTerrainLevelFromNoise(TerrainNoise *tn);
}; };