Core procedural primitives for heightmap generation, including noise functions (Perlin, Gabor, Voronoi, Phasor), terrain features (hills, craters, calderas, dunes), geometric shapes (disk, rectangle), and advanced patterns (DLA, Dendry). Supports both CPU and GPU-accelerated generation for complex terrain synthesis. More...

Namespaces
namespace	hmap

namespace	hmap::gpu

Enumerations
enum	hmap::VoronoiReturnType : int { hmap::F1_SQUARED , hmap::F2_SQUARED , hmap::F1TF2_SQUARED , hmap::F1DF2_SQUARED , hmap::F2MF1_SQUARED , hmap::EDGE_DISTANCE_EXP , hmap::EDGE_DISTANCE_SQUARED , hmap::CONSTANT , hmap::CONSTANT_F2MF1_SQUARED }
	Selects the value returned by the Voronoi evaluation. More...

enum	hmap::PrimitiveType : int { hmap::PRIM_BIQUAD_PULSE , hmap::PRIM_BUMP , hmap::PRIM_CONE , hmap::PRIM_CONE_SMOOTH , hmap::PRIM_CUBIC_PULSE , hmap::PRIM_SMOOTH_COSINE }
	Defines the primitive shape used for synthesis. More...

Functions
Array	hmap::get_primitive_base (const PrimitiveType &primitive_type, const Vec2< int > &shape, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a primitive shape as a 2D array.

Array	hmap::biquad_pulse (Vec2< int > shape, float gain=1.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a 'biquadratic pulse'.

Array	hmap::bump (Vec2< int > shape, float gain=1.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a bump.

Array	hmap::bump_lorentzian (Vec2< int > shape, float shape_factor=0.5f, float radius=0.5f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a 2D Lorentzian bump pattern.

Array	hmap::caldera (Vec2< int > shape, float radius, float sigma_inner, float sigma_outer, float z_bottom, const Array *p_noise, float noise_amp_r, float noise_ratio_z, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a caldera-shaped heightmap.

Array	hmap::caldera (Vec2< int > shape, float radius, float sigma_inner, float sigma_outer, float z_bottom, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Array	hmap::checkerboard (Vec2< int > shape, Vec2< float > kw, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a checkerboard heightmap.

Array	hmap::cone (Vec2< int > shape, float slope, float apex_elevation=1.f, bool smooth_profile=false, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic conical mountain heightmap.

Array	hmap::cone_complex (Vec2< int > shape, float alpha, float radius=0.5f, bool smooth_profile=true, float valley_amp=0.2f, int valley_nb=5, float valley_decay_ratio=0.5f, float valley_angle0=15.f, const ErosionProfile &erosion_profile=ErosionProfile::TRIANGLE_GRENIER, float erosion_delta=0.01f, float radial_waviness_amp=0.05f, float radial_waviness_kw=2.f, float bias_angle=30.f, float bias_amp=0.75f, float bias_exponent=1.f, Vec2< float > center={0.5f, 0.5f}, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a complex conical heightfield with valleys, directional bias, and radial waviness.

Array	hmap::cone_sigmoid (Vec2< int > shape, float alpha, float radius=0.5f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a smooth conical heightmap using a sigmoid-based profile.

Array	hmap::constant (Vec2< int > shape, float value=0.f)
	Return a constant value array.

Array	hmap::crater (Vec2< int > shape, float radius, float depth, float lip_decay, float lip_height_ratio=0.5f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a crater-shaped heightmap.

Array	hmap::cubic_pulse (Vec2< int > shape, const Array p_noise_x, const Array p_noise_y, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a cubic pulse array.

Array	hmap::dendry (Vec2< int > shape, Vec2< float > kw, uint seed, Array &control_function, float eps=0.05, int resolution=1, float displacement=0.075, int primitives_resolution_steps=3, float slope_power=2.f, float noise_amplitude_proportion=0.01, bool add_control_function=true, float control_function_overlap=0.5f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f}, int subsampling=1)
	Dendry is a locally computable procedural function that generates branching patterns at various scales (see [Gaillard2019]).

Array	hmap::dendry (Vec2< int > shape, Vec2< float > kw, uint seed, NoiseFunction &noise_function, float noise_function_offset=0.f, float noise_function_scaling=1.f, float eps=0.05, int resolution=1, float displacement=0.075, int primitives_resolution_steps=3, float slope_power=2.f, float noise_amplitude_proportion=0.01, bool add_control_function=true, float control_function_overlap=0.5f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::diffusion_limited_aggregation (Vec2< int > shape, float scale, uint seed, float seeding_radius=0.4f, float seeding_outer_radius_ratio=0.2f, float slope=8.f, float noise_ratio=0.2f)
	Generates a diffusion-limited aggregation (DLA) pattern.

Array	hmap::disk (Vec2< int > shape, float radius, float slope=1.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a disk-shaped heightmap with optional modifications.

Array	hmap::gabor_noise (Vec2< int > shape, float kw, float angle, int width, float density, uint seed)
	Return a sparse Gabor noise.

Array	hmap::gaussian_pulse (Vec2< int > shape, float sigma, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a gaussian_decay pulse kernel.

Array	hmap::island_land_mask (Vec2< int > shape, float radius, uint seed, float displacement=0.2f, NoiseType noise_type=NoiseType::SIMPLEX2S, float kw=4.f, int octaves=8, float weight=0.f, float persistence=0.5f, float lacunarity=2.f, const Vec2< float > &center={0.5f, 0.5f}, const Vec4< float > &bbox={0.f, 1.f, 0.f, 1.f})
	Generates a 2D island mask by perturbing a radial boundary with noise.

Array	hmap::noise (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence noise.

Array	hmap::noise_fbm (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm noise.

Array	hmap::noise_iq (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, float gradient_scale=0.05f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm noise.

Array	hmap::noise_jordan (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, float warp0=0.4f, float damp0=1.f, float warp_scale=0.4f, float damp_scale=1.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm noise.

Array	hmap::noise_parberry (Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, float mu=1.02f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherent fbm Parberry variant of Perlin noise.

Array	hmap::noise_pingpong (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm pingpong noise.

Array	hmap::noise_ridged (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, float k_smoothing=0.1f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm ridged noise.

Array	hmap::noise_swiss (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, float warp_scale=0.1f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence fbm swiss noise.

Array	hmap::paraboloid (Vec2< int > shape, float angle, float a, float b, float v0=0.f, bool reverse_x=false, bool reverse_y=false, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a paraboloid.

Array	hmap::peak (Vec2< int > shape, float radius, const Array *p_noise, float noise_r_amp, float noise_z_ratio, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a peak-shaped heightmap.

Array	hmap::phasor (PhasorProfile phasor_profile, Vec2< int > shape, float kw, const Array &angle, uint seed, float profile_delta=0.1f, float density_factor=1.f, float kernel_width_ratio=2.f, float phase_smoothing=2.f)
	Generates a phasor noise field based on a Gabor noise model and phase profile.

Array	hmap::phasor_fbm (PhasorProfile phasor_profile, Vec2< int > shape, float kw, const Array &angle, uint seed, float profile_delta=0.1f, float density_factor=1.f, float kernel_width_ratio=2.f, float phase_smoothing=2.f, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f)
	Generates a fractal Brownian motion (fBm) noise field using layered phasor profiles.

Array	hmap::rectangle (Vec2< int > shape, float rx, float ry, float angle, float slope=1.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a rectangle-shaped heightmap with optional modifications.

Array	hmap::rift (Vec2< int > shape, float angle, float slope, float width, bool sharp_bottom=false, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a rift function (Heaviside with an optional talus slope at the transition).

Array	hmap::slope (Vec2< int > shape, float angle, float slope, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array corresponding to a slope with a given overall.

Array	hmap::smooth_cosine (Vec2< int > shape, const Array p_noise_x, const Array p_noise_y, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a smooth cosine array.

Array	hmap::step (Vec2< int > shape, float angle, float slope, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec2< float > center={0.5f, 0.5f}, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a step function (Heaviside with an optional talus slope at the transition).

void	hmap::swirl (Array &dx, Array &dy, float amplitude=1.f, float exponent=1.f, const Array *p_noise=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generate displacements `dx` and `dy` to apply a swirl effect to another primitve.

Array	hmap::wave_dune (Vec2< int > shape, float kw, float angle, float xtop, float xbottom, float phase_shift=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a dune shape wave.

Array	hmap::wave_sine (Vec2< int > shape, float kw, float angle, float phase_shift=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a sine wave.

Array	hmap::wave_square (Vec2< int > shape, float kw, float angle, float phase_shift=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a square wave.

Array	hmap::wave_triangular (Vec2< int > shape, float kw, float angle, float slant_ratio, float phase_shift=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return a triangular wave.

Array	hmap::white (Vec2< int > shape, float a, float b, uint seed)
	Return an array filled with white noise.

Array	hmap::white_density_map (const Array &density_map, uint seed)
	Return an array filled `1` with a probability based on a density map.

Array	hmap::white_sparse (Vec2< int > shape, float a, float b, float density, uint seed)
	Return an array sparsely filled with white noise.

Array	hmap::white_sparse_binary (Vec2< int > shape, float density, uint seed)
	Return an array sparsely filled with random 0 and 1.

Array	hmap::worley_double (Vec2< int > shape, Vec2< float > kw, uint seed, float ratio=0.5f, float k=0.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with the maximum of two Worley (cellular) noises.

Array	hmap::gpu::badlands (Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float rugosity=0.2f, float angle=30.f, float k_smoothing=0.1f, float base_noise_amp=0.2f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic "badlands" terrain heightmap.

Array	hmap::gpu::basalt_field (Vec2< int > shape, Vec2< float > kw, uint seed, float warp_kw=4.f, float large_scale_warp_amp=0.2f, float large_scale_gain=6.f, float large_scale_amp=0.2f, float medium_scale_kw_ratio=3.f, float medium_scale_warp_amp=1.f, float medium_scale_gain=7.f, float medium_scale_amp=0.08f, float small_scale_kw_ratio=10.f, float small_scale_amp=0.1f, float small_scale_overlay_amp=0.002f, float rugosity_kw_ratio=1.f, float rugosity_amp=1.f, bool flatten_activate=true, float flatten_kw_ratio=1.f, float flatten_amp=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic procedural terrain resembling basaltic landforms.

Array	hmap::gpu::gabor_wave (Vec2< int > shape, Vec2< float > kw, uint seed, const Array &angle, float angle_spread_ratio=1.f, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence Gabor noise.

Array	hmap::gpu::gabor_wave (Vec2< int > shape, Vec2< float > kw, uint seed, float angle=0.f, float angle_spread_ratio=1.f, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::gpu::gabor_wave_fbm (Vec2< int > shape, Vec2< float > kw, uint seed, const Array &angle, float angle_spread_ratio=1.f, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence Gabor noise.

Array	hmap::gpu::gabor_wave_fbm (Vec2< int > shape, Vec2< float > kw, uint seed, float angle=0.f, float angle_spread_ratio=1.f, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::gpu::gavoronoise (Vec2< int > shape, Vec2< float > kw, uint seed, const Array &angle, float amplitude=0.05f, float angle_spread_ratio=1.f, Vec2< float > kw_multiplier={4.f, 4.f}, float slope_strength=1.f, float branch_strength=2.f, float z_cut_min=0.2f, float z_cut_max=1.f, int octaves=8, float persistence=0.4f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a 2D array using the GavoroNoise algorithm, which is a procedural noise technique for terrain generation and other applications.

Array	hmap::gpu::gavoronoise (Vec2< int > shape, Vec2< float > kw, uint seed, float angle=0.f, float amplitude=0.05f, float angle_spread_ratio=1.f, Vec2< float > kw_multiplier={4.f, 4.f}, float slope_strength=1.f, float branch_strength=2.f, float z_cut_min=0.2f, float z_cut_max=1.f, int octaves=8, float persistence=0.4f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::gpu::gavoronoise (const Array &base, Vec2< float > kw, uint seed, float amplitude=0.05f, Vec2< float > kw_multiplier={4.f, 4.f}, float slope_strength=1.f, float branch_strength=2.f, float z_cut_min=0.2f, float z_cut_max=1.f, int octaves=8, float persistence=0.4f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::gpu::hemisphere_field (Vec2< int > shape, Vec2< float > kw, uint seed, float rmin=0.05f, float rmax=0.8f, float amplitude_random_ratio=1.f, float density=0.1f, hmap::Vec2< float > jitter={1.f, 1.f}, float shift=0.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_noise_distance=nullptr, const Array p_density_multiplier=nullptr, const Array *p_size_multiplier=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a scalar field representing the signed distance to randomly generated hemispheres.

Array	hmap::gpu::hemisphere_field_fbm (Vec2< int > shape, Vec2< float > kw, uint seed, float rmin=0.05f, float rmax=0.8f, float amplitude_random_ratio=1.f, float density=0.1f, hmap::Vec2< float > jitter={0.5f, 0.5f}, float shift=0.1f, int octaves=8, float persistence=0.5f, float lacunarity=2.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_noise_distance=nullptr, const Array p_density_multiplier=nullptr, const Array *p_size_multiplier=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	See hmap::hemisphere_field.

Array	hmap::gpu::island (const Array &land_mask, const Array p_noise_r=nullptr, float apex_elevation=1.f, bool filter_distance=true, int filter_ir=32, float slope_min=0.1f, float slope_max=8.f, float slope_start=0.5f, float slope_end=1.f, float slope_noise_intensity=0.5f, float k_smooth=0.05f, float radial_noise_intensity=0.3f, float radial_profile_gain=2.f, float water_decay=0.05f, float water_depth=0.3f, float lee_angle=30.f, float lee_amp=0.f, float uplift_amp=0.f, Array p_water_depth=nullptr, Array *p_inland_mask=nullptr)
	Generates an island heightmap from a land mask using radial profiles, slope shaping, optional noise, and water attenuation.

Array	hmap::gpu::island (const Array &land_mask, uint seed, float noise_amp=0.07f, Vec2< float > noise_kw={4.f, 4.f}, int noise_octaves=8, float noise_rugosity=0.7f, float noise_angle=45.f, float noise_k_smoothing=0.05f, float apex_elevation=1.f, bool filter_distance=true, int filter_ir=32, float slope_min=0.1f, float slope_max=8.f, float slope_start=0.5f, float slope_end=1.f, float slope_noise_intensity=0.5f, float k_smooth=0.05f, float radial_noise_intensity=0.3f, float radial_profile_gain=2.f, float water_decay=0.05f, float water_depth=0.3f, float lee_angle=30.f, float lee_amp=0.f, float uplift_amp=0.f, Array p_water_depth=nullptr, Array p_inland_mask=nullptr)
	Generates an island heightmap from a land mask using internally generated FBM noise for radial perturbation and slope modulation.

Array	hmap::gpu::mountain_cone (Vec2< int > shape, uint seed, float scale=1.f, int octaves=8, float peak_kw=4.f, float rugosity=0.f, float angle=45.f, float k_smoothing=0.f, float gamma=0.5f, float cone_alpha=1.f, float ridge_amp=0.4f, float base_noise_amp=0.05f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a procedural "mountain cone" heightmap using fractal noise and Voronoi patterns.

Array	hmap::gpu::mountain_inselberg (Vec2< int > shape, uint seed, float scale=1.f, int octaves=8, float rugosity=0.2f, float angle=45.f, float gamma=1.1f, bool round_shape=false, bool add_deposition=true, float bulk_amp=0.2f, float base_noise_amp=0.2f, float k_smoothing=0.1f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic mountain-like inselberg (isolated hill) heightmap.

Array	hmap::gpu::mountain_range_radial (Vec2< int > shape, Vec2< float > kw, uint seed, float half_width=0.2f, float angle_spread_ratio=0.5f, float core_size_ratio=1.f, Vec2< float > center={0.5f, 0.5f}, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_angle=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a heightmap representing a radial mountain range.

Array	hmap::gpu::mountain_stump (Vec2< int > shape, uint seed, float scale=1.f, int octaves=8, float peak_kw=6.f, float rugosity=0.f, float angle=45.f, float k_smoothing=0.f, float gamma=0.25f, bool add_deposition=true, float ridge_amp=0.75f, float base_noise_amp=0.1f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a mountain-like heightmap with a flattened (stump-shaped) peak.

Array	hmap::gpu::mountain_tibesti (Vec2< int > shape, uint seed, float scale=1.f, int octaves=8, float peak_kw=20.f, float rugosity=0.f, float angle=30.f, float angle_spread_ratio=0.25f, float gamma=1.f, bool add_deposition=true, float bulk_amp=1.f, float base_noise_amp=0.1f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic "Tibesti" mountain heightmap.

Array	hmap::gpu::noise (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array *p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	See hmap::noise.

Array	hmap::gpu::noise_fbm (NoiseType noise_type, Vec2< int > shape, Vec2< float > kw, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_stretching=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	See hmap::noise_fbm.

Array	hmap::gpu::polygon_field (Vec2< int > shape, Vec2< float > kw, uint seed, float rmin=0.05f, float rmax=0.8f, float clamping_dist=0.1f, float clamping_k=0.1f, int n_vertices_min=3, int n_vertices_max=16, float density=0.5f, hmap::Vec2< float > jitter={0.5f, 0.5f}, float shift=0.1f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_noise_distance=nullptr, const Array p_density_multiplier=nullptr, const Array *p_size_multiplier=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a scalar field representing the signed distance to randomly generated polygons.

Array	hmap::gpu::polygon_field_fbm (Vec2< int > shape, Vec2< float > kw, uint seed, float rmin=0.05f, float rmax=0.8f, float clamping_dist=0.1f, float clamping_k=0.1f, int n_vertices_min=3, int n_vertices_max=16, float density=0.1f, hmap::Vec2< float > jitter={0.5f, 0.5f}, float shift=0.1f, int octaves=8, float persistence=0.5f, float lacunarity=2.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, const Array p_noise_distance=nullptr, const Array p_density_multiplier=nullptr, const Array *p_size_multiplier=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a scalar field representing the signed distance to randomly generated polygons combined with fractal Brownian motion (fBm) noise modulation.

Array	hmap::gpu::shattered_peak (Vec2< int > shape, uint seed, float scale=1.f, int octaves=8, float peak_kw=4.f, float rugosity=0.f, float angle=30.f, float gamma=1.f, bool add_deposition=true, float bulk_amp=0.3f, float base_noise_amp=0.1f, float k_smoothing=0.f, Vec2< float > center={0.5f, 0.5f}, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a synthetic "shattered peak" terrain heightmap.

Array	hmap::gpu::vorolines (Vec2< int > shape, float density, uint seed, float k_smoothing=0.f, float exp_sigma=0.f, float alpha=0.f, float alpha_span=M_PI, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f}, Vec4< float > bbox_points={0.f, 1.f, 0.f, 1.f})
	Generates a Voronoi-based pattern where cells are defined by proximity to random lines.

Array	hmap::gpu::vorolines_fbm (Vec2< int > shape, float density, uint seed, float k_smoothing=0.f, float exp_sigma=0.f, float alpha=0.f, float alpha_span=M_PI, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f}, Vec4< float > bbox_points={0.f, 1.f, 0.f, 1.f})
	Generates a Voronoi-based pattern using distances to lines defined by random points and angles, with additional fractal Brownian motion (fBm) noise modulation.

Array	hmap::gpu::voronoi (Vec2< int > shape, Vec2< float > kw, uint seed, Vec2< float > jitter={0.5f, 0.5f}, float k_smoothing=0.f, float exp_sigma=0.f, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a Voronoi diagram in a 2D array with configurable properties.

Array	hmap::gpu::voronoi_fbm (Vec2< int > shape, Vec2< float > kw, uint seed, Vec2< float > jitter={0.5f, 0.5f}, float k_smoothing=0.f, float exp_sigma=0.f, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a Voronoi diagram in a 2D array with configurable properties.

Array	hmap::gpu::voronoi_edge_distance (Vec2< int > shape, Vec2< float > kw, uint seed, Vec2< float > jitter={0.5f, 0.5f}, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Computes the Voronoi edge distance.

Array	hmap::gpu::voronoise (Vec2< int > shape, Vec2< float > kw, float u_param, float v_param, uint seed, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates a 2D Voronoi noise array.

Array	hmap::gpu::voronoise_fbm (Vec2< int > shape, Vec2< float > kw, float u_param, float v_param, uint seed, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Return an array filled with coherence Voronoise.

Array	hmap::gpu::vororand (Vec2< int > shape, float density, float variability, uint seed, float k_smoothing=0.f, float exp_sigma=0.f, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f}, Vec4< float > bbox_points={0.f, 1.f, 0.f, 1.f})
	Generates a 2D Voronoi-based scalar field using OpenCL.

Array	hmap::gpu::vororand (Vec2< int > shape, const std::vector< float > &xp, const std::vector< float > &yp, float k_smoothing=0.f, float exp_sigma=0.f, VoronoiReturnType return_type=VoronoiReturnType::F1_SQUARED, const Array p_noise_x=nullptr, const Array p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})

Array	hmap::gpu::wavelet_noise (Vec2< int > shape, Vec2< float > kw, uint seed, float kw_multiplier=2.f, float vorticity=0.f, float density=1.f, int octaves=8, float weight=0.7f, float persistence=0.5f, float lacunarity=2.f, const Array p_ctrl_param=nullptr, const Array p_noise_x=nullptr, const Array *p_noise_y=nullptr, Vec4< float > bbox={0.f, 1.f, 0.f, 1.f})
	Generates 2D wavelet noise using an OpenCL kernel.

Detailed Description

Core procedural primitives for heightmap generation, including noise functions (Perlin, Gabor, Voronoi, Phasor), terrain features (hills, craters, calderas, dunes), geometric shapes (disk, rectangle), and advanced patterns (DLA, Dendry). Supports both CPU and GPU-accelerated generation for complex terrain synthesis.

Author: Otto Link (otto..nosp@m.link.nosp@m..bv@g.nosp@m.mail.nosp@m..com)

Version: 0.1

Date: 2023-04-30

Author: Otto Link (otto..nosp@m.link.nosp@m..bv@g.nosp@m.mail.nosp@m..com)

Namespaces

Enumerations

Functions

Detailed Description