geo.hpp

Go to the documentation of this file.

/* 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 "highmap/array.hpp"
#include "highmap/functions.hpp"
#include "highmap/math/profiles.hpp"
 
namespace hmap
{
 
Array caldera(glm::ivec2   shape,
              float        radius,
              float        sigma_inner,
              float        sigma_outer,
              float        z_bottom,
              const Array *p_noise,
              float        noise_amp_r,
              float        noise_ratio_z,
              glm::vec2    center = {0.5f, 0.5f},
              glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
Array caldera(glm::ivec2 shape,
              float      radius,
              float      sigma_inner,
              float      sigma_outer,
              float      z_bottom,
              glm::vec2  center = {0.5f, 0.5f},
              glm::vec4  bbox = {0.f, 1.f, 0.f, 1.f}); 
 
Array crater(glm::ivec2   shape,
             float        radius,
             glm::vec2    center = {0.5f, 0.5f},
             float        angle = 30.f, // degs,
             float        inner_depth = 0.1f,
             float        inner_exp = 3.f,
             float        lip_height = 0.02f,
             float        lip_extent = 0.25f,
             float        lip_exp = 2.f,
             float        asym_ratio = 0.8f,
             float        central_peak_height = 0.01f,
             float        central_peak_extent = 0.4f,
             int          n_terraces = 0,
             float        terrace_extent = 0.1f,
             float        terrace_exp = 2.f,
             float        terrace_persistence = 0.5f,
             const Array *p_noise_r = nullptr,
             glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f},
             Array       *p_crater_mask = nullptr,
             Array       *p_inner_crater_mask = nullptr);
 
Array island_land_mask(glm::ivec2       shape,
                       float            radius,
                       std::uint32_t    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 glm::vec2 &center = {0.5f, 0.5f},
                       const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
Array rift(glm::ivec2    shape,
           float         angle,
           float         radius = 0.1f,
           float         axial_slope = 0.2f,
           float         depth = 0.5f,
           bool          scale_with_depth = true,
           RadialProfile profile = RadialProfile::RP_SMOOTHSTEP,
           float         profile_param = 0.f,
           float         bottom_extent = 0.1,
           float         bottom_depth = 0.05f,
           RadialProfile bottom_profile = RadialProfile::RP_SQRT,
           float         bottom_profile_param = 0.f,
           bool          bottom_force_minimum_depth = true,
           float         outer_slope = 0.5f,
           const Array  *p_noise_r = nullptr,
           const Array  *p_noise_offset = nullptr,
           glm::vec2     center = {0.5f, 0.5f},
           glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f},
           Array        *p_rift_mask = nullptr,
           Array        *p_bottom_mask = nullptr);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array badlands(glm::ivec2    shape,
               glm::vec2     kw,
               std::uint32_t 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,
               glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array basalt_field(glm::ivec2    shape,
                   glm::vec2     kw,
                   std::uint32_t 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,
                   glm::vec4     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,
             std::uint32_t seed,
             float         noise_amp = 0.07f,
             glm::vec2     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(glm::ivec2    shape,
                    std::uint32_t 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,
                    glm::vec2     center = {0.5f, 0.5f},
                    const Array  *p_noise_x = nullptr,
                    const Array  *p_noise_y = nullptr,
                    glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array mountain_inselberg(glm::ivec2    shape,
                         std::uint32_t 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,
                         glm::vec2     center = {0.5f, 0.5f},
                         const Array  *p_noise_x = nullptr,
                         const Array  *p_noise_y = nullptr,
                         glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array mountain_range_radial(glm::ivec2    shape,
                            glm::vec2     kw,
                            std::uint32_t seed,
                            float         half_width = 0.2f,
                            float         angle_spread_ratio = 0.5f,
                            float         core_size_ratio = 1.f,
                            glm::vec2     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,
                            glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array mountain_stump(glm::ivec2    shape,
                     std::uint32_t 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,
                     glm::vec2     center = {0.5f, 0.5f},
                     const Array  *p_noise_x = nullptr,
                     const Array  *p_noise_y = nullptr,
                     glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array mountain_tibesti(glm::ivec2    shape,
                       std::uint32_t 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,
                       glm::vec2     center = {0.5f, 0.5f},
                       const Array  *p_noise_x = nullptr,
                       const Array  *p_noise_y = nullptr,
                       glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array plates(glm::ivec2    shape,
             glm::vec2     kw,
             std::uint32_t seed,
             float         talus,
             int           direction = 0,
             float         mix_ratio = 0.9f,
             float         base_noise_amp = 0.05f,
             float         kw_multiplier = 2.f,
             int           octaves = 8,
             float         rugosity = 0.f,
             glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array shattered_peak(glm::ivec2    shape,
                     std::uint32_t 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,
                     glm::vec2     center = {0.5f, 0.5f},
                     const Array  *p_noise_x = nullptr,
                     const Array  *p_noise_y = nullptr,
                     glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap::gpu