mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

Codechange: Rename height_t/amplitude_t to Height/Amplitude.

pull/10708/head
Peter Nelson 2023-04-23 13:05:24 +01:00 committed by PeterN
parent 3f811246b1
commit c3cea45ebc
1 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
src/tgp.cpp
View File

@ -151,17 +151,17 @@
*/ */
/** Fixed point type for heights */ /** Fixed point type for heights */
typedef int16 height_t; using Height = int16;
static const int height_decimal_bits = 4; static const int height_decimal_bits = 4;
/** Fixed point array for amplitudes (and percent values) */ /** Fixed point array for amplitudes (and percent values) */
typedef int amplitude_t; using Amplitude = int;
static const int amplitude_decimal_bits = 10; static const int amplitude_decimal_bits = 10;
/** Height map - allocated array of heights (MapSizeX() + 1) x (MapSizeY() + 1) */ /** Height map - allocated array of heights (MapSizeX() + 1) x (MapSizeY() + 1) */
struct HeightMap struct HeightMap
{ {
std::vector<height_t> h; //< array of heights std::vector<Height> h; //< array of heights
/* Even though the sizes are always positive, there are many cases where /* Even though the sizes are always positive, there are many cases where
* X and Y need to be signed integers due to subtractions. */ * X and Y need to be signed integers due to subtractions. */
int dim_x; //< height map size_x Map::SizeX() + 1 int dim_x; //< height map size_x Map::SizeX() + 1
@ -174,7 +174,7 @@ struct HeightMap
* @param y Y position * @param y Y position
* @return height as fixed point number * @return height as fixed point number
*/ */
inline height_t &height(uint x, uint y) inline Height &height(uint x, uint y)
{ {
return h[x + y * dim_x]; return h[x + y * dim_x];
} }
@ -183,24 +183,24 @@ struct HeightMap
/** Global height map instance */ /** Global height map instance */
static HeightMap _height_map = { {}, 0, 0, 0 }; static HeightMap _height_map = { {}, 0, 0, 0 };
/** Conversion: int to height_t */ /** Conversion: int to Height */
#define I2H(i) ((i) << height_decimal_bits) #define I2H(i) ((i) << height_decimal_bits)
/** Conversion: height_t to int */ /** Conversion: Height to int */
#define H2I(i) ((i) >> height_decimal_bits) #define H2I(i) ((i) >> height_decimal_bits)
/** Conversion: int to amplitude_t */ /** Conversion: int to Amplitude */
#define I2A(i) ((i) << amplitude_decimal_bits) #define I2A(i) ((i) << amplitude_decimal_bits)
/** Conversion: amplitude_t to int */ /** Conversion: Amplitude to int */
#define A2I(i) ((i) >> amplitude_decimal_bits) #define A2I(i) ((i) >> amplitude_decimal_bits)
/** Conversion: amplitude_t to height_t */ /** Conversion: Amplitude to Height */
#define A2H(a) ((a) >> (amplitude_decimal_bits - height_decimal_bits)) #define A2H(a) ((a) >> (amplitude_decimal_bits - height_decimal_bits))
/** Maximum number of TGP noise frequencies. */ /** Maximum number of TGP noise frequencies. */
static const int MAX_TGP_FREQUENCIES = 10; static const int MAX_TGP_FREQUENCIES = 10;
/** Desired water percentage (100% == 1024) - indexed by _settings_game.difficulty.quantity_sea_lakes */ /** Desired water percentage (100% == 1024) - indexed by _settings_game.difficulty.quantity_sea_lakes */
static const amplitude_t _water_percent[4] = {70, 170, 270, 420}; static const Amplitude _water_percent[4] = {70, 170, 270, 420};
/** /**
* Gets the maximum allowed height while generating a map based on * Gets the maximum allowed height while generating a map based on
@ -208,7 +208,7 @@ static const amplitude_t _water_percent[4] = {70, 170, 270, 420};
* @return The maximum height for the map generation. * @return The maximum height for the map generation.
* @note Values should never be lower than 3 since the minimum snowline height is 2. * @note Values should never be lower than 3 since the minimum snowline height is 2.
*/ */
static height_t TGPGetMaxHeight() static Height TGPGetMaxHeight()
{ {
if (_settings_game.difficulty.terrain_type == CUSTOM_TERRAIN_TYPE_NUMBER_DIFFICULTY) { if (_settings_game.difficulty.terrain_type == CUSTOM_TERRAIN_TYPE_NUMBER_DIFFICULTY) {
/* TGP never reaches this height; this means that if a user inputs "2", /* TGP never reaches this height; this means that if a user inputs "2",
@ -261,10 +261,10 @@ uint GetEstimationTGPMapHeight()
* @param frequency The frequency to get the amplitudes for * @param frequency The frequency to get the amplitudes for
* @return The amplitudes to apply to the map. * @return The amplitudes to apply to the map.
*/ */
static amplitude_t GetAmplitude(int frequency) static Amplitude GetAmplitude(int frequency)
{ {
/* Base noise amplitudes (multiplied by 1024) and indexed by "smoothness setting" and log2(frequency). */ /* Base noise amplitudes (multiplied by 1024) and indexed by "smoothness setting" and log2(frequency). */
static const amplitude_t amplitudes[][7] = { static const Amplitude amplitudes[][7] = {
/* lowest frequency ...... highest (every corner) */ /* lowest frequency ...... highest (every corner) */
{16000, 5600, 1968, 688, 240, 16, 16}, ///< Very smooth {16000, 5600, 1968, 688, 240, 16, 16}, ///< Very smooth
{24000, 12800, 6400, 2700, 1024, 128, 16}, ///< Smooth {24000, 12800, 6400, 2700, 1024, 128, 16}, ///< Smooth
@ -287,14 +287,14 @@ static amplitude_t GetAmplitude(int frequency)
/* Get the table index, and return that value if possible. */ /* Get the table index, and return that value if possible. */
int index = frequency - MAX_TGP_FREQUENCIES + lengthof(amplitudes[smoothness]); int index = frequency - MAX_TGP_FREQUENCIES + lengthof(amplitudes[smoothness]);
amplitude_t amplitude = amplitudes[smoothness][std::max(0, index)]; Amplitude amplitude = amplitudes[smoothness][std::max(0, index)];
if (index >= 0) return amplitude; if (index >= 0) return amplitude;
/* We need to extrapolate the amplitude. */ /* We need to extrapolate the amplitude. */
double extrapolation_factor = extrapolation_factors[smoothness]; double extrapolation_factor = extrapolation_factors[smoothness];
int height_range = I2H(16); int height_range = I2H(16);
do { do {
amplitude = (amplitude_t)(extrapolation_factor * (double)amplitude); amplitude = (Amplitude)(extrapolation_factor * (double)amplitude);
height_range <<= 1; height_range <<= 1;
index++; index++;
} while (index < 0); } while (index < 0);
@ -344,7 +344,7 @@ static inline void FreeHeightMap()
* @param rMax Limit of result * @param rMax Limit of result
* @return generated height * @return generated height
*/ */
static inline height_t RandomHeight(amplitude_t rMax) static inline Height RandomHeight(Amplitude rMax)
{ {
/* Spread height into range -rMax..+rMax */ /* Spread height into range -rMax..+rMax */
return A2H(RandomRange(2 * rMax + 1) - rMax); return A2H(RandomRange(2 * rMax + 1) - rMax);
@ -366,7 +366,7 @@ static void HeightMapGenerate()
bool first = true; bool first = true;
for (int frequency = start; frequency < MAX_TGP_FREQUENCIES; frequency++) { for (int frequency = start; frequency < MAX_TGP_FREQUENCIES; frequency++) {
const amplitude_t amplitude = GetAmplitude(frequency); const Amplitude amplitude = GetAmplitude(frequency);
/* Ignore zero amplitudes; it means our map isn't height enough for this /* Ignore zero amplitudes; it means our map isn't height enough for this
* amplitude, so ignore it and continue with the next set of amplitude. */ * amplitude, so ignore it and continue with the next set of amplitude. */
@ -378,7 +378,7 @@ static void HeightMapGenerate()
/* This is first round, we need to establish base heights with step = size_min */ /* This is first round, we need to establish base heights with step = size_min */
for (int y = 0; y <= _height_map.size_y; y += step) { for (int y = 0; y <= _height_map.size_y; y += step) {
for (int x = 0; x <= _height_map.size_x; x += step) { for (int x = 0; x <= _height_map.size_x; x += step) {
height_t height = (amplitude > 0) ? RandomHeight(amplitude) : 0; Height height = (amplitude > 0) ? RandomHeight(amplitude) : 0;
_height_map.height(x, y) = height; _height_map.height(x, y) = height;
} }
} }
@ -390,9 +390,9 @@ static void HeightMapGenerate()
* Interpolate height values at odd x, even y tiles */ * Interpolate height values at odd x, even y tiles */
for (int y = 0; y <= _height_map.size_y; y += 2 * step) { for (int y = 0; y <= _height_map.size_y; y += 2 * step) {
for (int x = 0; x <= _height_map.size_x - 2 * step; x += 2 * step) { for (int x = 0; x <= _height_map.size_x - 2 * step; x += 2 * step) {
height_t h00 = _height_map.height(x + 0 * step, y); Height h00 = _height_map.height(x + 0 * step, y);
height_t h02 = _height_map.height(x + 2 * step, y); Height h02 = _height_map.height(x + 2 * step, y);
height_t h01 = (h00 + h02) / 2; Height h01 = (h00 + h02) / 2;
_height_map.height(x + 1 * step, y) = h01; _height_map.height(x + 1 * step, y) = h01;
} }
} }
@ -400,9 +400,9 @@ static void HeightMapGenerate()
/* Interpolate height values at odd y tiles */ /* Interpolate height values at odd y tiles */
for (int y = 0; y <= _height_map.size_y - 2 * step; y += 2 * step) { for (int y = 0; y <= _height_map.size_y - 2 * step; y += 2 * step) {
for (int x = 0; x <= _height_map.size_x; x += step) { for (int x = 0; x <= _height_map.size_x; x += step) {
height_t h00 = _height_map.height(x, y + 0 * step); Height h00 = _height_map.height(x, y + 0 * step);
height_t h20 = _height_map.height(x, y + 2 * step); Height h20 = _height_map.height(x, y + 2 * step);
height_t h10 = (h00 + h20) / 2; Height h10 = (h00 + h20) / 2;
_height_map.height(x, y + 1 * step) = h10; _height_map.height(x, y + 1 * step) = h10;
} }
} }
@ -417,21 +417,21 @@ static void HeightMapGenerate()
} }
/** Returns min, max and average height from height map */ /** Returns min, max and average height from height map */
static void HeightMapGetMinMaxAvg(height_t *min_ptr, height_t *max_ptr, height_t *avg_ptr) static void HeightMapGetMinMaxAvg(Height *min_ptr, Height *max_ptr, Height *avg_ptr)
{ {
height_t h_min, h_max, h_avg; Height h_min, h_max, h_avg;
int64 h_accu = 0; int64 h_accu = 0;
h_min = h_max = _height_map.height(0, 0); h_min = h_max = _height_map.height(0, 0);
/* Get h_min, h_max and accumulate heights into h_accu */ /* Get h_min, h_max and accumulate heights into h_accu */
for (const height_t &h : _height_map.h) { for (const Height &h : _height_map.h) {
if (h < h_min) h_min = h; if (h < h_min) h_min = h;
if (h > h_max) h_max = h; if (h > h_max) h_max = h;
h_accu += h; h_accu += h;
} }
/* Get average height */ /* Get average height */
h_avg = (height_t)(h_accu / (_height_map.size_x * _height_map.size_y)); h_avg = (Height)(h_accu / (_height_map.size_x * _height_map.size_y));
/* Return required results */ /* Return required results */
if (min_ptr != nullptr) *min_ptr = h_min; if (min_ptr != nullptr) *min_ptr = h_min;
@ -440,12 +440,12 @@ static void HeightMapGetMinMaxAvg(height_t *min_ptr, height_t *max_ptr, height_t
} }
/** Dill histogram and return pointer to its base point - to the count of zero heights */ /** Dill histogram and return pointer to its base point - to the count of zero heights */
static int *HeightMapMakeHistogram(height_t h_min, height_t h_max, int *hist_buf) static int *HeightMapMakeHistogram(Height h_min, Height h_max, int *hist_buf)
{ {
int *hist = hist_buf - h_min; int *hist = hist_buf - h_min;
/* Count the heights and fill the histogram */ /* Count the heights and fill the histogram */
for (const height_t &h : _height_map.h){ for (const Height &h : _height_map.h){
assert(h >= h_min); assert(h >= h_min);
assert(h <= h_max); assert(h <= h_max);
hist[h]++; hist[h]++;
@ -454,9 +454,9 @@ static int *HeightMapMakeHistogram(height_t h_min, height_t h_max, int *hist_buf
} }
/** Applies sine wave redistribution onto height map */ /** Applies sine wave redistribution onto height map */
static void HeightMapSineTransform(height_t h_min, height_t h_max) static void HeightMapSineTransform(Height h_min, Height h_max)
{ {
for (height_t &h : _height_map.h) { for (Height &h : _height_map.h) {
double fheight; double fheight;
if (h < h_min) continue; if (h < h_min) continue;
@ -522,7 +522,7 @@ static void HeightMapSineTransform(height_t h_min, height_t h_max)
break; break;
} }
/* Transform it back into h_min..h_max space */ /* Transform it back into h_min..h_max space */
h = (height_t)(fheight * (h_max - h_min) + h_min); h = (Height)(fheight * (h_max - h_min) + h_min);
if (h < 0) h = I2H(0); if (h < 0) h = I2H(0);
if (h >= h_max) h = h_max - 1; if (h >= h_max) h = h_max - 1;
} }
@ -546,15 +546,15 @@ static void HeightMapSineTransform(height_t h_min, height_t h_max)
*/ */
static void HeightMapCurves(uint level) static void HeightMapCurves(uint level)
{ {
height_t mh = TGPGetMaxHeight() - I2H(1); // height levels above sea level only Height mh = TGPGetMaxHeight() - I2H(1); // height levels above sea level only
/** Basically scale height X to height Y. Everything in between is interpolated. */ /** Basically scale height X to height Y. Everything in between is interpolated. */
struct ControlPoint { struct ControlPoint {
height_t x; ///< The height to scale from. Height x; ///< The height to scale from.
height_t y; ///< The height to scale to. Height y; ///< The height to scale to.
}; };
/* Scaled curve maps; value is in height_ts. */ /* Scaled curve maps; value is in height_ts. */
#define F(fraction) ((height_t)(fraction * mh)) #define F(fraction) ((Height)(fraction * mh))
const ControlPoint curve_map_1[] = { { F(0.0), F(0.0) }, { F(0.8), F(0.13) }, { F(1.0), F(0.4) } }; const ControlPoint curve_map_1[] = { { F(0.0), F(0.0) }, { F(0.8), F(0.13) }, { F(1.0), F(0.4) } };
const ControlPoint curve_map_2[] = { { F(0.0), F(0.0) }, { F(0.53), F(0.13) }, { F(0.8), F(0.27) }, { F(1.0), F(0.6) } }; const ControlPoint curve_map_2[] = { { F(0.0), F(0.0) }, { F(0.53), F(0.13) }, { F(0.8), F(0.27) }, { F(1.0), F(0.6) } };
const ControlPoint curve_map_3[] = { { F(0.0), F(0.0) }, { F(0.53), F(0.27) }, { F(0.8), F(0.57) }, { F(1.0), F(0.8) } }; const ControlPoint curve_map_3[] = { { F(0.0), F(0.0) }, { F(0.53), F(0.27) }, { F(0.8), F(0.57) }, { F(1.0), F(0.8) } };
@ -573,7 +573,7 @@ static void HeightMapCurves(uint level)
{ lengthof(curve_map_4), curve_map_4 }, { lengthof(curve_map_4), curve_map_4 },
}; };
height_t ht[lengthof(curve_maps)]; Height ht[lengthof(curve_maps)];
MemSetT(ht, 0, lengthof(ht)); MemSetT(ht, 0, lengthof(ht));
/* Set up a grid to choose curve maps based on location; attempt to get a somewhat square grid */ /* Set up a grid to choose curve maps based on location; attempt to get a somewhat square grid */
@ -634,7 +634,7 @@ static void HeightMapCurves(uint level)
corner_bits |= 1 << corner_c; corner_bits |= 1 << corner_c;
corner_bits |= 1 << corner_d; corner_bits |= 1 << corner_d;
height_t *h = &_height_map.height(x, y); Height *h = &_height_map.height(x, y);
/* Do not touch sea level */ /* Do not touch sea level */
if (*h < I2H(1)) continue; if (*h < I2H(1)) continue;
@ -664,7 +664,7 @@ static void HeightMapCurves(uint level)
} }
/* Apply interpolation of curve map results. */ /* Apply interpolation of curve map results. */
*h = (height_t)((ht[corner_a] * yri + ht[corner_b] * yr) * xri + (ht[corner_c] * yri + ht[corner_d] * yr) * xr); *h = (Height)((ht[corner_a] * yri + ht[corner_b] * yr) * xri + (ht[corner_c] * yri + ht[corner_d] * yr) * xr);
/* Readd sea level */ /* Readd sea level */
*h += I2H(1); *h += I2H(1);
@ -673,9 +673,9 @@ static void HeightMapCurves(uint level)
} }
/** Adjusts heights in height map to contain required amount of water tiles */ /** Adjusts heights in height map to contain required amount of water tiles */
static void HeightMapAdjustWaterLevel(amplitude_t water_percent, height_t h_max_new) static void HeightMapAdjustWaterLevel(Amplitude water_percent, Height h_max_new)
{ {
height_t h_min, h_max, h_avg, h_water_level; Height h_min, h_max, h_avg, h_water_level;
int64 water_tiles, desired_water_tiles; int64 water_tiles, desired_water_tiles;
int *hist; int *hist;
@ -701,9 +701,9 @@ static void HeightMapAdjustWaterLevel(amplitude_t water_percent, height_t h_max_
* values from range: h_water_level..h_max are transformed into 0..h_max_new * values from range: h_water_level..h_max are transformed into 0..h_max_new
* where h_max_new is depending on terrain type and map size. * where h_max_new is depending on terrain type and map size.
*/ */
for (height_t &h : _height_map.h) { for (Height &h : _height_map.h) {
/* Transform height from range h_water_level..h_max into 0..h_max_new range */ /* Transform height from range h_water_level..h_max into 0..h_max_new range */
h = (height_t)(((int)h_max_new) * (h - h_water_level) / (h_max - h_water_level)) + I2H(1); h = (Height)(((int)h_max_new) * (h - h_water_level) / (h_max - h_water_level)) + I2H(1);
/* Make sure all values are in the proper range (0..h_max_new) */ /* Make sure all values are in the proper range (0..h_max_new) */
if (h < 0) h = I2H(0); if (h < 0) h = I2H(0);
if (h >= h_max_new) h = h_max_new - 1; if (h >= h_max_new) h = h_max_new - 1;
@ -799,8 +799,8 @@ static void HeightMapSmoothCoastInDirection(int org_x, int org_y, int dir_x, int
int ed; // coast distance from edge int ed; // coast distance from edge
int depth; int depth;
height_t h_prev = I2H(1); Height h_prev = I2H(1);
height_t h; Height h;
assert(IsValidXY(org_x, org_y)); assert(IsValidXY(org_x, org_y));
@ -849,17 +849,17 @@ static void HeightMapSmoothCoasts(uint8 water_borders)
* the most it can change is one level. When OTTD can support cliffs, this * the most it can change is one level. When OTTD can support cliffs, this
* routine may not be necessary. * routine may not be necessary.
*/ */
static void HeightMapSmoothSlopes(height_t dh_max) static void HeightMapSmoothSlopes(Height dh_max)
{ {
for (int y = 0; y <= (int)_height_map.size_y; y++) { for (int y = 0; y <= (int)_height_map.size_y; y++) {
for (int x = 0; x <= (int)_height_map.size_x; x++) { for (int x = 0; x <= (int)_height_map.size_x; x++) {
height_t h_max = std::min(_height_map.height(x > 0 ? x - 1 : x, y), _height_map.height(x, y > 0 ? y - 1 : y)) + dh_max; Height h_max = std::min(_height_map.height(x > 0 ? x - 1 : x, y), _height_map.height(x, y > 0 ? y - 1 : y)) + dh_max;
if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max; if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max;
} }
} }
for (int y = _height_map.size_y; y >= 0; y--) { for (int y = _height_map.size_y; y >= 0; y--) {
for (int x = _height_map.size_x; x >= 0; x--) { for (int x = _height_map.size_x; x >= 0; x--) {
height_t h_max = std::min(_height_map.height(x < _height_map.size_x ? x + 1 : x, y), _height_map.height(x, y < _height_map.size_y ? y + 1 : y)) + dh_max; Height h_max = std::min(_height_map.height(x < _height_map.size_x ? x + 1 : x, y), _height_map.height(x, y < _height_map.size_y ? y + 1 : y)) + dh_max;
if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max; if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max;
} }
} }
@ -875,9 +875,9 @@ static void HeightMapSmoothSlopes(height_t dh_max)
static void HeightMapNormalize() static void HeightMapNormalize()
{ {
int sea_level_setting = _settings_game.difficulty.quantity_sea_lakes; int sea_level_setting = _settings_game.difficulty.quantity_sea_lakes;
const amplitude_t water_percent = sea_level_setting != (int)CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY ? _water_percent[sea_level_setting] : _settings_game.game_creation.custom_sea_level * 1024 / 100; const Amplitude water_percent = sea_level_setting != (int)CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY ? _water_percent[sea_level_setting] : _settings_game.game_creation.custom_sea_level * 1024 / 100;
const height_t h_max_new = TGPGetMaxHeight(); const Height h_max_new = TGPGetMaxHeight();
const height_t roughness = 7 + 3 * _settings_game.game_creation.tgen_smoothness; const Height roughness = 7 + 3 * _settings_game.game_creation.tgen_smoothness;
HeightMapAdjustWaterLevel(water_percent, h_max_new); HeightMapAdjustWaterLevel(water_percent, h_max_new);