/*
* libtcod 1.6.0
* Copyright (c) 2008,2009,2010,2012,2013 Jice & Mingos
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * The name of Jice or Mingos may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY JICE AND MINGOS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL JICE OR MINGOS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _TCOD_HEIGHTMAP_HPP
#define _TCOD_HEIGHTMAP_HPP
/**
@PageName heightmap
@PageCategory Roguelike toolkits
@PageTitle Heightmap toolkit
@PageDesc This toolkit allows to create a 2D grid of float values using various algorithms.
The code using the heightmap toolkit can be automatically generated with the heightmap tool (hmtool) included in the libtcod package.
*/
class TCODLIB_API TCODHeightMap {
public :
int w,h;
float *values;
/**
@PageName heightmap_init
@PageFather heightmap
@PageTitle Creating a heightmap
@FuncTitle Creating an empty map
@FuncDesc As with other modules, you have to create a heightmap object first :
Note that whereas most other modules use opaque structs, the TCOD_heightmap_t fields can be freely accessed. Thus, the TCOD_heightmap_new function returns a TCOD_heightmap_t pointer, not a TCOD_heightmap_t. The w and h fields should not be modified after the heightmap creation. The newly created heightmap is filled with 0.0 values.
@Cpp TCODHeightMap::TCODHeightMap(int w, int h)
@C
typedef struct {
int w,h;
float *values;
} TCOD_heightmap_t;
TCOD_heightmap_t *TCOD_heightmap_new(int w,int h)
@Py heightmap_new(w,h)
@C# TCODHeightMap::TCODHeightMap(int w, int h)
@Param w,h The width and height of the heightmap.
@CppEx TCODHeightMap myMap(50,50);
@CEx TCOD_heightmap_t *my_map=TCOD_heightmap_new(50,50);
@PyEx
map=libtcod.heightmap_new(50,50)
print map.w, map.h
*/
TCODHeightMap(int w, int h);
/**
@PageName heightmap_init
@FuncTitle Destroying a heightmap
@FuncDesc To release the resources used by a heightmap, destroy it with :
@Cpp TCODHeightMap::~TCODHeightMap()
@C void TCOD_heightmap_delete(TCOD_heightmap_t *hm)
@Py heightmap_delete(hm)
@C# void TCODHeightMap::Dispose()
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
*/
virtual ~TCODHeightMap();
/**
@PageName heightmap_base
@PageFather heightmap
@PageTitle Basic operations
@PageDesc Those are simple operations applied either on a single map cell or on every map cell.
@FuncTitle Setting a cell value
@FuncDesc Once the heightmap has been created, you can do some basic operations on the values inside it.
You can set a single value :
@Cpp void TCODHeightMap::setValue(int x, int y, float v)
@C void TCOD_heightmap_set_value(TCOD_heightmap_t *hm, int x, int y, float value)
@Py heightmap_set_value(hm, x, y, value)
@C# void TCODHeightMap::setValue(int x, int y, float v)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the cells to modify inside the map.
0 <= x < map width
0 <= y < map height
@Param value The new value of the map cell.
*/
inline void setValue(int x, int y, float v) {
values[x+y*w]=v;
}
/**
@PageName heightmap_base
@FuncTitle Adding a float value to all cells
@Cpp void TCODHeightMap::add(float value)
@C void TCOD_heightmap_add(TCOD_heightmap_t *hm, float value)
@Py heightmap_add(hm, value)
@C# void TCODHeightMap::add(float value)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param value Value to add to every cell.
*/
void add(float f);
/**
@PageName heightmap_base
@FuncTitle Multiplying all values by a float
@Cpp void TCODHeightMap::scale(float value)
@C void TCOD_heightmap_scale(TCOD_heightmap_t *hm, float value)
@Py heightmap_scale(hm, value)
@C# void TCODHeightMap::scale(float value)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param value Every cell's value is multiplied by this value.
*/
void scale(float f);
/**
@PageName heightmap_base
@FuncTitle Resetting all values to 0.0
@Cpp void TCODHeightMap::clear()
@C void TCOD_heightmap_clear(TCOD_heightmap_t *hm)
@Py heightmap_clear(hm)
@C# void TCODHeightMap::clear()
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
*/
void clear(); // resets all values to 0.0
/**
@PageName heightmap_base
@FuncTitle Clamping all values
@Cpp void TCODHeightMap::clamp(float min, float max)
@C void TCOD_heightmap_clamp(TCOD_heightmap_t *hm, float min, float max)
@Py heightmap_clamp(hm, mi, ma)
@C# void TCODHeightMap::clamp(float min, float max)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param min,max Every cell value is clamped between min and max.
min < max
*/
void clamp(float min, float max);
/**
@PageName heightmap_base
@FuncTitle Copying values from another heightmap
@Cpp void TCODHeightMap::copy(const TCODHeightMap *source)
@C void TCOD_heightmap_copy(const TCOD_heightmap_t *source,TCOD_heightmap_t *dest)
@Py heightmap_copy(source,dest)
@C# void TCODHeightMap::copy(TCODHeightMap source)
@Param source Each cell value from the source heightmap is copied in the destination (this for C++) heightmap.
The source and destination heightmap must have the same width and height.
@Param dest In the C and python versions, the address of the destination heightmap.
*/
void copy(const TCODHeightMap *source);
/**
@PageName heightmap_base
@FuncTitle Normalizing values
@Cpp void TCODHeightMap::normalize(float min=0.0f, float max=1.0f)
@C void TCOD_heightmap_normalize(TCOD_heightmap_t *hm, float min, float max)
@Py heightmap_normalize(hm, mi=0.0, ma=1.0)
@C#
void TCODHeightMap::normalize()
void TCODHeightMap::normalize(float min)
void TCODHeightMap::normalize(float min, float max)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param min,max The whole heightmap is translated and scaled so that the lowest cell value becomes min and the highest cell value becomes max
min < max
*/
void normalize(float newMin=0.0f, float newMax=1.0f); // scales the values to the range [newMin;newMax]
/**
@PageName heightmap_base
@FuncTitle Doing a lerp operation between two heightmaps
@Cpp void TCODHeightMap::lerp(const TCODHeightMap *a, const TCODHeightMap *b,float coef)
@C void TCOD_heightmap_lerp_hm(const TCOD_heightmap_t *a, const TCOD_heightmap_t *b, TCOD_heightmap_t *res, float coef)
@Py heightmap_lerp_hm(a, b, res, coef)
@C# void TCODHeightMap::lerp(TCODHeightMap a, TCODHeightMap b, float coef)
@Param a First heightmap in the lerp operation.
@Param b Second heightmap in the lerp operation.
@Param coef lerp coefficient.
For each cell in the destination map (this for C++), value = a.value + (b.value - a.value) * coef
@Param res In the C and python versions, the address of the destination heightmap.
*/
void lerp(const TCODHeightMap *a, const TCODHeightMap *b,float coef);
/**
@PageName heightmap_base
@FuncTitle Adding two heightmaps
@Cpp void TCODHeightMap::add(const TCODHeightMap *a, const TCODHeightMap *b)
@C void TCOD_heightmap_add_hm(const TCOD_heightmap_t *a, const TCOD_heightmap_t *b, TCOD_heightmap_t *res)
@Py heightmap_add_hm(a, b, res)
@C# void TCODHeightMap::add(TCODHeightMap a, TCODHeightMap b)
@Param a First heightmap.
@Param b Second heightmap. For each cell in the destination map (this for C++), value = a.value + b.value
@Param res In the C and python versions, the address of the destination heightmap.
*/
void add(const TCODHeightMap *a, const TCODHeightMap *b);
/**
@PageName heightmap_base
@FuncTitle Multiplying two heightmaps
@Cpp void TCODHeightMap::multiply(const TCODHeightMap *a, const TCODHeightMap *b)
@C void TCOD_heightmap_multiply_hm(const TCOD_heightmap_t *a, const TCOD_heightmap_t *b, TCOD_heightmap_t *res)
@Py heightmap_multiply_hm(a, b, res)
@C# void TCODHeightMap::multiply(TCODHeightMap a, TCODHeightMap b)
@Param a First heightmap.
@Param b Second heightmap. For each cell in the destination map (this for C++), value = a.value * b.value
@Param res In the C and python versions, the address of the destination heightmap.
*/
void multiply(const TCODHeightMap *a, const TCODHeightMap *b);
/**
@PageName heightmap_modify
@PageFather heightmap
@PageTitle Modifying the heightmap
@PageDesc Those are advanced operations involving several or all map cells.
@FuncTitle Add hills
@FuncDesc This function adds a hill (a half spheroid) at given position.
@Cpp void TCODHeightMap::addHill(float x, float y, float radius, float height)
@C void TCOD_heightmap_add_hill(TCOD_heightmap_t *hm, float x, float y, float radius, float height)
@Py heightmap_add_hill(hm, x, y, radius, height)
@C# void TCODHeightMap::addHill(float x, float y, float radius, float height)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the center of the hill.
0 <= x < map width
0 <= y < map height
@Param radius The hill radius.
@Param height The hill height. If height == radius or -radius, the hill is a half-sphere.
*/
void addHill(float x, float y, float radius, float height); // adds a hill (half sphere) at given position
/**
@PageName heightmap_modify
@FuncTitle Dig hills
@FuncDesc This function takes the highest value (if height > 0) or the lowest (if height < 0) between the map and the hill.
It's main goal is to carve things in maps (like rivers) by digging hills along a curve.
@Cpp void TCODHeightMap::digHill(float hx, float hy, float hradius, float height)
@C void TCOD_heightmap_dig_hill(TCOD_heightmap_t *hm, float x, float y, float radius, float height)
@Py heightmap_dig_hill(hm, x, y, radius, height)
@C# void TCODHeightMap::digHill(float hx, float hy, float hradius, float height)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the center of the hill.
0 <= x < map width
0 <= y < map height
@Param radius The hill radius.
@Param height The hill height. Can be < 0 or > 0
*/
void digHill(float hx, float hy, float hradius, float height);
/**
@PageName heightmap_modify
@FuncTitle Simulate rain erosion
@FuncDesc This function simulates the effect of rain drops on the terrain, resulting in erosion patterns.
@Cpp void TCODHeightMap::rainErosion(int nbDrops,float erosionCoef,float sedimentationCoef,TCODRandom *rnd)
@C void TCOD_heightmap_rain_erosion(TCOD_heightmap_t *hm, int nbDrops,float erosionCoef,float sedimentationCoef,TCOD_random_t rnd)
@Py heightmap_rain_erosion(hm, nbDrops,erosionCoef,sedimentationCoef,rnd=0)
@C# void TCODHeightMap::rainErosion(int nbDrops, float erosionCoef, float sedimentationCoef, TCODRandom rnd)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param nbDrops Number of rain drops to simulate. Should be at least width * height.
@Param erosionCoef Amount of ground eroded on the drop's path.
@Param sedimentationCoef Amount of ground deposited when the drops stops to flow
@Param rnd RNG to use, NULL for default generator.
*/
void rainErosion(int nbDrops,float erosionCoef,float sedimentationCoef,TCODRandom *rnd);
/**
@PageName heightmap_modify
@FuncTitle Do a generic transformation
@FuncDesc This function allows you to apply a generic transformation on the map, so that each resulting cell value is the weighted sum of several neighbour cells. This can be used to smooth/sharpen the map. See examples below for a simple horizontal smoothing kernel : replace value(x,y) with 0.33*value(x-1,y) + 0.33*value(x,y) + 0.33*value(x+1,y).To do this, you need a kernel of size 3 (the sum involves 3 surrounding cells). The dx,dy array will contain :
dx=-1,dy = 0 for cell x-1,y
dx=1,dy=0 for cell x+1,y
dx=0,dy=0 for current cell (x,y)
The weight array will contain 0.33 for each cell.
@Cpp void TCODHeightMap::kernelTransform(int kernelSize, int *dx, int *dy, float *weight, float minLevel,float maxLevel)
@C void TCOD_heightmap_kernel_transform(TCOD_heightmap_t *hm, int kernelsize, int *dx, int *dy, float *weight, float minLevel,float maxLevel)
@Py heightmap_kernel_transform(hm, kernelsize, dx, dy, weight, minLevel,maxLevel)
@C# void TCODHeightMap::kernelTransform(int kernelSize, int[] dx, int[] dy, float[] weight, float minLevel, float maxLevel)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
kernelSize Number of neighbour cells involved.
@Param dx,dy Array of kernelSize cells coordinates. The coordinates are relative to the current cell (0,0) is current cell, (-1,0) is west cell, (0,-1) is north cell, (1,0) is east cell, (0,1) is south cell, ...
@Param weight Array of kernelSize cells weight. The value of each neighbour cell is scaled by its corresponding weight
@Param minLevel The transformation is only applied to cells which value is >= minLevel.
@Param maxLevel The transformation is only applied to cells which value is <= maxLevel.
@CEx
int dx [] = {-1,1,0};
int dy[] = {0,0,0};
float weight[] = {0.33f,0.33f,0.33f};
TCOD_heightMap_kernel_transform(heightmap,3,dx,dy,weight,0.0f,1.0f);
@CppEx
int dx [] = {-1,1,0};
int dy[] = {0,0,0};
float weight[] = {0.33f,0.33f,0.33f};
heightmap->kernelTransform(heightmap,3,dx,dy,weight,0.0f,1.0f);
*/
void kernelTransform(int kernelSize, const int *dx, const int *dy, const float *weight, float minLevel,float maxLevel);
/**
@PageName heightmap_modify
@FuncTitle Add a Voronoi diagram
@FuncDesc This function adds values from a Voronoi diagram to the map.
@Cpp void TCODHeightMap::addVoronoi(int nbPoints, int nbCoef, float *coef,TCODRandom *rnd)
@C void TCOD_heightmap_add_voronoi(TCOD_heightmap_t *hm, int nbPoints, int nbCoef, float *coef,TCOD_random_t rnd)
@Py heightmap_add_voronoi(hm, nbPoints, nbCoef, coef,rnd=0)
@C# void TCODHeightMap::addVoronoi(int nbPoints, int nbCoef, float[] coef, TCODRandom rnd)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param nbPoints Number of Voronoi sites.
@Param nbCoef The diagram value is calculated from the nbCoef closest sites.
@Param coef The distance to each site is scaled by the corresponding coef.
Closest site : coef[0], second closest site : coef[1], ...
@Param rnd RNG to use, NULL for default generator.
*/
void addVoronoi(int nbPoints, int nbCoef, const float *coef,TCODRandom *rnd);
/**
@PageName heightmap_modify
@FuncTitle Add a fbm
This function adds values from a simplex fbm function to the map.
@Cpp void TCODHeightMap::addFbm(TCODNoise *noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
@C void TCOD_heightmap_add_fbm(TCOD_heightmap_t *hm, TCOD_noise_t noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
@Py heightmap_add_fbm(hm, noise,mulx, muly, addx, addy, octaves, delta, scale)
@C# void TCODHeightMap::addFbm(TCODNoise noise, float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param noise The 2D noise to use.
@Param mulx, muly / addx, addy The noise coordinate for map cell (x,y) are (x + addx)*mulx / width , (y + addy)*muly / height.
Those values allow you to scale and translate the noise function over the heightmap.
@Param octaves Number of octaves in the fbm sum.
@Param delta / scale The value added to the heightmap is delta + noise * scale.
@Param noise is between -1.0 and 1.0
*/
void addFbm(TCODNoise *noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale);
/**
@PageName heightmap_modify
@FuncTitle Scale with a fbm
@FuncDesc This function works exactly as the previous one, but it multiplies the resulting value instead of adding it to the heightmap.
@Cpp void TCODHeightMap::scaleFbm(TCODNoise *noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
@C void TCOD_heightmap_scale_fbm(TCOD_heightmap_t *hm, TCOD_noise_t noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
@Py heightmap_scale_fbm(hm, noise,mulx, muly, addx, addy, octaves, delta, scale)
@C# void TCODHeightMap::scaleFbm(TCODNoise noise, float mulx, float muly, float addx, float addy, float octaves, float delta, float scale)
*/
void scaleFbm(TCODNoise *noise,float mulx, float muly, float addx, float addy, float octaves, float delta, float scale);
/**
@PageName heightmap_modify
@FuncTitle Dig along a Bezier curve
@FuncDesc This function carve a path along a cubic Bezier curve using the digHill function.
Could be used for roads/rivers/...
Both radius and depth can vary linearly along the path.
@Cpp void TCODHeightMap::digBezier(int px[4], int py[4], float startRadius, float startDepth, float endRadius, float endDepth)
@C void TCOD_heightmap_dig_bezier(TCOD_heightmap_t *hm, int px[4], int py[4], float startRadius, float startDepth, float endRadius, float endDepth)
@Py heightmap_dig_bezier(hm, px, py, startRadius, startDepth, endRadius, endDepth)
@C# void TCODHeightMap::digBezier(int[] px, int[] py, float startRadius, float startDepth, float endRadius, float endDepth)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param px,py The coordinates of the 4 Bezier control points.
@Param startRadius The path radius in map cells at point P0. Might be < 1.0
@Param startDepth The path depth at point P0.
@Param endRadius The path radius in map cells at point P3. Might be < 1.0
@Param endDepth The path depth at point P3.
*/
void digBezier(int px[4], int py[4], float startRadius, float startDepth, float endRadius, float endDepth);
/**
@PageName heightmap_read
@PageFather heightmap
@PageTitle Reading data from the heightmap
@PageDesc Those functions return raw or computed information about the heightmap.
@FuncTitle Get the value of a cell
@FuncDesc This function returns the height value of a map cell.
@Cpp float TCODHeightMap::getValue(int x, int y) const
@C float TCOD_heightmap_get_value(const TCOD_heightmap_t *hm, int x, int y)
@Py heightmap_get_value(hm, x, y)
@C# float TCODHeightMap::getValue(int x, int y)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the map cell.
0 <= x < map width
0 <= y < map height
*/
inline float getValue(int x, int y) const {
return values[x+y*w];
}
/**
@PageName heightmap_read
@FuncTitle Interpolate the height
@FuncDesc This function returns the interpolated height at non integer coordinates.
@Cpp float TCODHeightMap::getInterpolatedValue(float x, float y) const
@C float TCOD_heightmap_get_interpolated_value(const TCOD_heightmap_t *hm, float x, float y)
@Py heightmap_get_interpolated_value(hm, x, y)
@C# float TCODHeightMap::getInterpolatedValue(float x, float y)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the map cell.
0 <= x < map width
0 <= y < map height
*/
float getInterpolatedValue(float x, float y) const;
/**
@PageName heightmap_read
@FuncTitle Get the map slope
@FuncDesc This function returns the slope between 0 and PI/2 at given coordinates.
@Cpp float TCODHeightMap::getSlope(int x, int y) const
@C float TCOD_heightmap_get_slope(const TCOD_heightmap_t *hm, int x, int y)
@Py heightmap_get_slope(hm, x, y)
@C# float TCODHeightMap::getSlope(int x, int y)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the map cell.
0 <= x < map width
0 <= y < map height
*/
float getSlope(int x, int y) const; // returns the slope in radian between 0 and PI/2
/**
@PageName heightmap_read
@FuncTitle Get the map normal
@FuncDesc This function returns the map normal at given coordinates.
@Cpp void TCODHeightMap::getNormal(float x, float y,float n[3], float waterLevel=0.0f) const
@C void TCOD_heightmap_get_normal(const TCOD_heightmap_t *hm, float x, float y, float n[3], float waterLevel)
@Py heightmap_get_normal(hm, x, y, waterLevel) # returns nx,ny,nz
@C# void TCODHeightMap::getNormal(float x, float y, float[] n, float waterLevel)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param x,y Coordinates of the map cell.
0 <= x < map width
0 <= y < map height
@Param n The function stores the normalized normal vector in this array.
@Param waterLevel The map height is clamped at waterLevel so that the sea is flat.
*/
void getNormal(float x, float y,float n[3], float waterLevel=0.0f) const; // returns the surface normal or (0,0,1) if beyond water level.
/**
@PageName heightmap_read
@FuncTitle Count the map cells inside a height range
@FuncDesc This function returns the number of map cells which value is between min and max.
@Cpp int TCODHeightMap::countCells(float min,float max) const
@C int TCOD_heightmap_count_cells(const TCOD_heightmap_t *hm, float min, float max)
@Py heightmap_count_cells(hm, min, max)
@C# int TCODHeightMap::countCells(float min, float max)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param min,max Only cells which value is >=min and <= max are counted.
*/
int countCells(float min,float max) const;
/**
@PageName heightmap_read
@FuncTitle Check if the map is an island
@FuncDesc This function checks if the cells on the map border are below a certain height.
@Cpp bool TCODHeightMap::hasLandOnBorder(float waterLevel) const
@C bool TCOD_heightmap_has_land_on_border(const TCOD_heightmap_t *hm, float waterLevel)
@Py heightmap_has_land_on_border(hm, waterLevel)
@C# bool TCODHeightMap::hasLandOnBorder(float waterLevel)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param waterLevel Return true only if no border cell is > waterLevel.
*/
bool hasLandOnBorder(float waterLevel) const;
/**
@PageName heightmap_read
@FuncTitle Get the map min and max values
@FuncDesc This function calculates the min and max of all values inside the map.
@Cpp void TCODHeightMap::getMinMax(float *min, float *max) const
@C void TCOD_heightmap_get_minmax(const TCOD_heightmap_t *hm, float *min, float *max)
@Py heightmap_get_minmax(hm) # returns min,max
@C# void TCODHeightMap::getMinMax(out float min, out float max)
@Param hm In the C version, the address of the heightmap struct returned by the creation function.
@Param min, max The min and max values are returned in these variables.
*/
void getMinMax(float *min, float *max) const;
// void heatErosion(int nbPass,float minSlope,float erosionCoef,float sedimentationCoef,TCODRandom *rnd);
/**
@PageName heightmap_modify
@FuncTitle Generate a map with mid-point displacement
@FuncDesc This algorithm generates a realistic fractal heightmap using the <a href="http://en.wikipedia.org/wiki/Diamond-square_algorithm">diamond-square</a> (or random midpoint displacement) algorithm.
The roughness range should be comprised between 0.4 and 0.6. The image below show the same map with roughness varying from 0.4 to 0.6.
<img src="midpoint.png" />
It's also a good habit to normalize the map after using this algorithm to avoid unexpected heights.
@Cpp void TCODHeightMap::midPointDisplacement(TCODRandom *rng=NULL,float roughness=0.45f)
@C void TCOD_heightmap_mid_point_displacement(TCOD_heightmap_t *hm, TCOD_random_t rnd, float roughness)
@Py heightmap_mid_point_displacement(hm, rng, roughness)
@Param hm In the C and python version, the adress of the heightmap struct returned by the creation function.
@Param rng Random number generation to use, or NULL/0 to use the default one.
@Param roughness Map roughness.
*/
void midPointDisplacement(TCODRandom *rnd = NULL, float roughness=0.45f);
void islandify(float seaLevel,TCODRandom *rnd); // lowers the terrain near the heightmap borders
// TODO : checks island connectivity with floodfill
private :
// void setMPDHeight(TCODRandom *rnd,int x,int y, float z, float offset);
// void setMDPHeightSquare(TCODRandom *rnd,int x, int y, int initsz, int sz,float offset);
};
#endif