authoring.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/geometry/path.hpp"
 
namespace hmap
{
 
class Cloud; // from highmap/geometry.hpp
 
enum StampingBlendMethod : int
{
  ADD,            
  MAXIMUM,        
  MAXIMUM_SMOOTH, 
  MINIMUM,        
  MINIMUM_SMOOTH, 
  MULTIPLY,       
  SUBSTRACT,      
};
 
void alter_elevation(Array       &array,
                     const Cloud &cloud,
                     int          ir,
                     float        footprint_ratio = 1.f,
                     glm::vec2    shift = {0.f, 0.f},
                     glm::vec2    scale = {1.f, 1.f});
 
Array base_elevation(glm::ivec2                             shape,
                     const std::vector<std::vector<float>> &values,
                     float                                  width_factor = 1.f,
                     const Array                           *p_noise_x = nullptr,
                     const Array                           *p_noise_y = nullptr,
                     const Array *p_stretching = nullptr,
                     glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
Array flatbed_carve(glm::ivec2    shape,
                    const Path   &path,
                    float         bottom_extent = 32.f, // pixels
                    float         vmin = 0.1f,
                    float         depth = 0.05f,
                    float         falloff_distance = 128.f,
                    float         outer_slope = 0.1f,
                    bool          preserve_bedshape = true,
                    RadialProfile radial_profile = RadialProfile::RP_GAIN,
                    float         radial_profile_parameter = 2.f,
                    Array        *p_falloff_mask = nullptr,
                    const Array  *p_noise_r = nullptr,
                    glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
void flatbed_carve(Array        &z,
                   const Path   &path,
                   float         bottom_extent = 32.f, // pixels
                   float         vmin = 0.1f,
                   float         depth = 0.05f,
                   float         falloff_distance = 128.f,
                   float         outer_slope = 0.1f,
                   bool          preserve_bedshape = true,
                   RadialProfile radial_profile = RadialProfile::RP_GAIN,
                   float         radial_profile_parameter = 2.f,
                   Array        *p_falloff_mask = nullptr,
                   const Array  *p_noise_r = nullptr,
                   glm::vec4     bbox = {0.f, 1.f, 0.f, 1.f});
 
Array reverse_midpoint(const Array &array,
                       uint         seed,
                       float        noise_scale = 1.f,
                       float        threshold = 0.f);
 
Array ridgelines(glm::ivec2                shape,
                 const std::vector<float> &xr,
                 const std::vector<float> &yr,
                 const std::vector<float> &zr,
                 float                     slope,
                 float                     k_smoothing = 1.f,
                 float                     width = 0.1f,
                 float                     vmin = 0.f,
                 glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f},
                 const Array              *p_noise_x = nullptr,
                 const Array              *p_noise_y = nullptr,
                 const Array              *p_stretching = nullptr,
                 glm::vec4                 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
Array ridgelines_bezier(glm::ivec2                shape,
                        const std::vector<float> &xr,
                        const std::vector<float> &yr,
                        const std::vector<float> &zr,
                        float                     slope,
                        float                     k_smoothing = 1.f,
                        float                     width = 0.1f,
                        float                     vmin = 0.f,
                        glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f},
                        const Array              *p_noise_x = nullptr,
                        const Array              *p_noise_y = nullptr,
                        const Array              *p_stretching = nullptr,
                        glm::vec4 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
Array stamping(glm::ivec2                shape,
               const std::vector<float> &xr,
               const std::vector<float> &yr,
               const std::vector<float> &zr,
               Array                     kernel,
               int                       kernel_ir,
               bool                      kernel_scale_radius,
               bool                      kernel_scale_amplitude,
               StampingBlendMethod       blend_method,
               uint                      seed,
               float                     k_smoothing = 0.1f,
               bool                      kernel_flip = true,
               bool                      kernel_rotate = false,
               glm::vec4                 bbox_array = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap