HighMap/primitives_8hpp_source.html

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General

   Public License. The full license is in the file LICENSE, distributed with

   this software. */


#pragma once


#include "FastNoiseLite.h"


#include "highmap/array.hpp"

#include "highmap/erosion.hpp"

#include "highmap/functions.hpp"


#define HMAP_GRADIENT_OFFSET 0.001f


namespace hmap

{


enum VoronoiReturnType : int

{

  F1_SQUARED,

  F2_SQUARED,

  F1TF2_SQUARED,

  F1DF2_SQUARED,

  F2MF1_SQUARED,

  EDGE_DISTANCE_EXP,

  EDGE_DISTANCE_SQUARED,

  CONSTANT,

  CONSTANT_F2MF1_SQUARED

};


enum PrimitiveType : int

{

  PRIM_BIQUAD_PULSE,

  PRIM_BUMP,

  PRIM_CONE,

  PRIM_CONE_SMOOTH,

  PRIM_CUBIC_PULSE,

  PRIM_SMOOTH_COSINE,

};


Array 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});


Array 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});


Array bump(Vec2<int>    shape,

           float        gain = 1.f,

           const Array *p_ctrl_param = nullptr, // gain multiplier

           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});


Array bump_lorentzian(

    Vec2<int>    shape,

    float        shape_factor = 0.5f,

    float        radius = 0.5f,

    const Array *p_ctrl_param = nullptr, // shape_factor multiplier

    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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array constant(Vec2<int> shape, float value = 0.f);


Array 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});


Array 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});


Array 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);


Array 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 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);


Array 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});


Array gabor_noise(Vec2<int> shape,

                  float     kw,

                  float     angle,

                  int       width,

                  float     density,

                  uint      seed);


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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);


Array 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);


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


void 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array white(Vec2<int> shape, float a, float b, uint seed);


Array white_density_map(const Array &density_map, uint seed);


Array white_sparse(Vec2<int> shape, float a, float b, float density, uint seed);


Array white_sparse_binary(Vec2<int> shape, float density, uint seed);


Array 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});


} // namespace hmap


namespace hmap::gpu

{


Array 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});


Array 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});


Array 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});


Array 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 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});


Array 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 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});


Array 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 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 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});


Array 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});


Array 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);


Array 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);


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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});


Array 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 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});


} // namespace hmap::gpu

array.hpp
Declaration of the Array class for 2D floating-point arrays with various mathematical operations and ...

uint
unsigned int uint
Definition array.hpp:14

erosion.hpp
Implements hydraulic and thermal erosion algorithms for terrain modeling, including particle-based fl...

functions.hpp
Defines modular function objects for procedural generation, including noise algorithms (Perlin,...

hmap::gpu
Definition blending.hpp:186

hmap::gpu::polygon_field
Array 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.
Definition primitives_gpu.cpp:578

hmap::gpu::shattered_peak
Array 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.
Definition shattered_peak.cpp:13

hmap::gpu::basalt_field
Array 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.
Definition basalt_field.cpp:13

hmap::gpu::voronoi
Array 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.
Definition primitives_gpu.cpp:828

hmap::gpu::badlands
Array 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.
Definition badlands.cpp:13

hmap::gpu::voronoise_fbm
Array 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.
Definition primitives_gpu.cpp:955

hmap::gpu::voronoise
Array 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.
Definition primitives_gpu.cpp:920

hmap::gpu::noise_fbm
Array 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.
Definition primitives_gpu.cpp:530

hmap::gpu::noise
Array 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.
Definition primitives_gpu.cpp:493

hmap::gpu::polygon_field_fbm
Array 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 wit...
Definition primitives_gpu.cpp:638

hmap::gpu::mountain_range_radial
Array 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.
Definition primitives_gpu.cpp:438

hmap::gpu::gabor_wave
Array 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.
Definition primitives_gpu.cpp:42

hmap::gpu::mountain_stump
Array 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.
Definition mountain_stump.cpp:13

hmap::gpu::hemisphere_field_fbm
Array 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.
Definition primitives_gpu.cpp:378

hmap::gpu::hemisphere_field
Array 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.
Definition primitives_gpu.cpp:324

hmap::gpu::vorolines
Array 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.
Definition primitives_gpu.cpp:704

hmap::gpu::mountain_tibesti
Array 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.
Definition mountain_tibesti.cpp:13

hmap::gpu::gabor_wave_fbm
Array 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.
Definition primitives_gpu.cpp:85

hmap::gpu::rugosity
Array rugosity(const Array &z, int ir, bool convex=true)
See hmap::rugosity.
Definition features_gpu.cpp:72

hmap::gpu::voronoi_fbm
Array 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.
Definition primitives_gpu.cpp:870

hmap::gpu::voronoi_edge_distance
Array 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.
Definition primitives_gpu.cpp:1001

hmap::gpu::mountain_cone
Array 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.
Definition mountain_cone.cpp:13

hmap::gpu::vorolines_fbm
Array 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,...
Definition primitives_gpu.cpp:783

hmap::gpu::vororand
Array 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.
Definition primitives_gpu.cpp:1037

hmap::gpu::mountain_inselberg
Array 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.
Definition mountain_inselberg.cpp:13

hmap::gpu::wavelet_noise
Array 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.
Definition primitives_gpu.cpp:1129

hmap::gpu::gavoronoise
Array 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 terra...
Definition primitives_gpu.cpp:166

hmap::gpu::island
Array 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,...
Definition island.cpp:108

hmap
Definition algebra.hpp:28

hmap::noise_jordan
Array 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.
Definition noise.cpp:115

hmap::noise
Array 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.
Definition noise.cpp:16

hmap::smooth_cosine
Array smooth_cosine(Vec2< int > shape)
Generate a smooth cosine kernel.
Definition kernels.cpp:406

hmap::wave_sine
Array 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.
Definition wave.cpp:43

hmap::phasor_fbm
Array 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.
Definition phasor.cpp:111

hmap::diffusion_limited_aggregation
Array 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.
Definition diffusion_limited_aggregation.cpp:14

hmap::wave_dune
Array 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.
Definition wave.cpp:15

hmap::dendry
Array 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 scale...
Definition dendry.cpp:19

hmap::ErosionProfile
ErosionProfile
Procedural erosion angular profile type.
Definition erosion.hpp:42

hmap::TRIANGLE_GRENIER
@ TRIANGLE_GRENIER
Definition erosion.hpp:48

hmap::biquad_pulse
Array 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'.
Definition primitives.cpp:19

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

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

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

hmap::island_land_mask
Array 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.
Definition island.cpp:16

hmap::noise_fbm
Array 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.
Definition noise.cpp:41

hmap::gaussian_pulse
Array 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.
Definition primitives.cpp:163

hmap::wave_triangular
Array 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.
Definition wave.cpp:91

hmap::PrimitiveType
PrimitiveType
Defines the primitive shape used for synthesis.
Definition primitives.hpp:53

hmap::PRIM_BIQUAD_PULSE
@ PRIM_BIQUAD_PULSE
Definition primitives.hpp:54

hmap::PRIM_CONE_SMOOTH
@ PRIM_CONE_SMOOTH
Definition primitives.hpp:57

hmap::PRIM_BUMP
@ PRIM_BUMP
Definition primitives.hpp:55

hmap::PRIM_SMOOTH_COSINE
@ PRIM_SMOOTH_COSINE
Definition primitives.hpp:59

hmap::PRIM_CUBIC_PULSE
@ PRIM_CUBIC_PULSE
Definition primitives.hpp:58

hmap::PRIM_CONE
@ PRIM_CONE
Definition primitives.hpp:56

hmap::crater
Array 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.
Definition geo.cpp:94

hmap::worley_double
Array 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.
Definition worley.cpp:15

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

hmap::PhasorProfile
PhasorProfile
Phasor angular profile type.
Definition math.hpp:54

hmap::rift
Array 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).
Definition primitives.cpp:250

hmap::noise_swiss
Array 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.
Definition noise.cpp:268

hmap::noise_ridged
Array 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.
Definition noise.cpp:230

hmap::bump
Array 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.
Definition primitives.cpp:41

hmap::bump_lorentzian
Array 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.
Definition primitives.cpp:63

hmap::get_primitive_base
Array 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.
Definition primitives.cpp:357

hmap::checkerboard
Array 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.
Definition checkerboard.cpp:12

hmap::VoronoiReturnType
VoronoiReturnType
Selects the value returned by the Voronoi evaluation.
Definition primitives.hpp:36

hmap::EDGE_DISTANCE_SQUARED
@ EDGE_DISTANCE_SQUARED
Squared edge distance.
Definition primitives.hpp:43

hmap::F1_SQUARED
@ F1_SQUARED
Returns F1^2.
Definition primitives.hpp:37

hmap::CONSTANT_F2MF1_SQUARED
@ CONSTANT_F2MF1_SQUARED
Constant × (F2 - F1)^2.
Definition primitives.hpp:45

hmap::F2_SQUARED
@ F2_SQUARED
Returns F2^2.
Definition primitives.hpp:38

hmap::CONSTANT
@ CONSTANT
Constant value.
Definition primitives.hpp:44

hmap::F1TF2_SQUARED
@ F1TF2_SQUARED
Returns (F1 * F2)^2.
Definition primitives.hpp:39

hmap::F2MF1_SQUARED
@ F2MF1_SQUARED
Returns (F2 - F1)^2.
Definition primitives.hpp:41

hmap::F1DF2_SQUARED
@ F1DF2_SQUARED
Returns (F1 / F2)^2.
Definition primitives.hpp:40

hmap::EDGE_DISTANCE_EXP
@ EDGE_DISTANCE_EXP
Exponential edge distance.
Definition primitives.hpp:42

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

hmap::peak
Array 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.
Definition geo.cpp:122

hmap::noise_pingpong
Array 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.
Definition noise.cpp:194

hmap::cone
Array cone(Vec2< int > shape)
Generates a cone-shaped kernel array.
Definition kernels.cpp:56

hmap::phasor
Array 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.
Definition phasor.cpp:16

hmap::swirl
void 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.
Definition swirl.cpp:16

hmap::angle
float angle(const Point &p1, const Point &p2)
Computes the angle between two points relative to the x-axis.
Definition points.cpp:42

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

hmap::step
Array 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).
Definition primitives.cpp:332

hmap::noise_iq
Array 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.
Definition noise.cpp:77

hmap::gain
void gain(Array &array, float factor, const Array *p_mask)
Apply a gain correction to the array elements.
Definition filters.cpp:346

hmap::NoiseType
NoiseType
Enumeration of various noise types used for procedural generation.
Definition functions.hpp:62

hmap::SIMPLEX2S
@ SIMPLEX2S
OpenSimplex2S.
Definition functions.hpp:68

hmap::caldera
Array 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.
Definition geo.cpp:16

hmap::cone_complex
Array 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.
Definition cone.cpp:73

hmap::wave_square
Array 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.
Definition wave.cpp:67

hmap::disk
Array disk(Vec2< int > shape)
Generates a disk-shaped kernel footprint.
Definition kernels.cpp:200

hmap::slope
Array 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.
Definition primitives.cpp:279

hmap::paraboloid
Array 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.
Definition primitives.cpp:185

hmap::noise_parberry
Array 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.
Definition noise.cpp:159

hmap::rectangle
Array 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.
Definition primitives.cpp:225

hmap::cubic_pulse
Array cubic_pulse(Vec2< int > shape)
Generates a cubic pulse kernel array.
Definition kernels.cpp:97

hmap::cone_sigmoid
Array 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.
Definition cone.cpp:154

hmap::Vec2
Vec2 class for basic manipulation of 2D vectors.
Definition algebra.hpp:40