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/functions.hpp"


#define HMAP_GRADIENT_OFFSET 0.001f


namespace hmap

{


// F1: the distance to the closest point in space

// F2: the distance to the second closest point in space


enum VoronoiReturnType : int

{

  F1_SQUARED,

  F2_SQUARED,

  F1TF2_SQUARED, // F1 * F2

  F1DF2_SQUARED, // F1 / F2

  F2MF1_SQUARED, // F2 - F1

  EDGE_DISTANCE_EXP,

  EDGE_DISTANCE_SQUARED,

  CONSTANT,

  CONSTANT_F2MF1_SQUARED

};


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


} // 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

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

hmap::gpu
Definition blending.hpp:151

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:472

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:726

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:853

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:818

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:422

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:383

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:534

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:328

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::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:602

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:86

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:768

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:899

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:681

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:935

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:169

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::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::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::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:133

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::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:220

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::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
Definition primitives.hpp:31

hmap::EDGE_DISTANCE_SQUARED
@ EDGE_DISTANCE_SQUARED
Definition primitives.hpp:38

hmap::F1_SQUARED
@ F1_SQUARED
Definition primitives.hpp:32

hmap::CONSTANT_F2MF1_SQUARED
@ CONSTANT_F2MF1_SQUARED
Definition primitives.hpp:40

hmap::F2_SQUARED
@ F2_SQUARED
Definition primitives.hpp:33

hmap::CONSTANT
@ CONSTANT
Definition primitives.hpp:39

hmap::F1TF2_SQUARED
@ F1TF2_SQUARED
Definition primitives.hpp:34

hmap::F2MF1_SQUARED
@ F2MF1_SQUARED
Definition primitives.hpp:36

hmap::F1DF2_SQUARED
@ F1DF2_SQUARED
Definition primitives.hpp:35

hmap::EDGE_DISTANCE_EXP
@ EDGE_DISTANCE_EXP
Definition primitives.hpp:37

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::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:272

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:347

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

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::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:249

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:155

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:195

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