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 }

Functions
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::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::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::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::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::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::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::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::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})

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