functions.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 <cmath>
#include <cstdint>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
#include "FastNoiseLite.h"
 
#include "highmap/array.hpp"
#include "highmap/math/core.hpp"
 
#define HMAP_FCT_XY_TYPE std::function<float(float, float, float)>
 
#define HMAP_GRADIENT_OFFSET 0.001f
 
namespace hmap
{
 
std::function<float(float, float)> make_xy_function_from_array(
    const Array     &array,
    const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
 
enum NoiseType : int
{
  PARBERRY,       
  PERLIN,         
  PERLIN_BILLOW,  
  PERLIN_HALF,    
  SIMPLEX2,       
  SIMPLEX2S,      
  VALUE,          
  VALUE_CUBIC,    
  VALUE_DELAUNAY, 
  VALUE_LINEAR,   
  WORLEY,         
  WORLEY_DOUBLE,  
  WORLEY_VALUE,   
};
 
//----------------------------------------
// Base Function class and derived
//----------------------------------------
 
class Function
{
public:
  Function() : delegate([](float, float, float) { return 0.f; })
  {
  }
 
  virtual ~Function() = default;
 
  explicit Function(HMAP_FCT_XY_TYPE delegate) : delegate(std::move(delegate))
  {
  }
 
  HMAP_FCT_XY_TYPE get_delegate() const;
 
  float get_value(float x, float y, float ctrl_param) const;
 
  void set_delegate(HMAP_FCT_XY_TYPE new_delegate);
 
private:
  HMAP_FCT_XY_TYPE delegate; 
};
 
class ArrayFunction : public Function
{
public:
  ArrayFunction(Array array, glm::vec2 kw, bool periodic = true);
 
  void set_array(Array new_array)
  {
    this->array = new_array;
  }
 
protected:
  glm::vec2 kw;  
  bool periodic; 
 
private:
  Array array; 
};
 
class BiquadFunction : public Function
{
public:
  BiquadFunction(float gain, glm::vec2 center);
 
protected:
  float     gain;   
  glm::vec2 center; 
};
 
class BumpFunction : public Function
{
public:
  BumpFunction(float gain, glm::vec2 center);
 
protected:
  float     gain;   
  glm::vec2 center; 
};
 
class CraterFunction : public Function
{
public:
  CraterFunction(float     radius,
                 float     depth,
                 float     lip_decay,
                 float     lip_height_ratio,
                 glm::vec2 center);
 
protected:
  float     radius;           
  float     depth;            
  float     lip_decay;        
  float     lip_height_ratio; 
  glm::vec2 center;           
};
 
class DiskFunction : public Function
{
public:
  DiskFunction(float radius, float slope, glm::vec2 center);
 
protected:
  float     radius; 
  float     slope;  
  glm::vec2 center; 
};
 
class GaussianPulseFunction : public Function
{
public:
  GaussianPulseFunction(float sigma, glm::vec2 center);
 
  void set_sigma(float new_sigma)
  {
    this->sigma = new_sigma;
    this->inv_sigma2 = 1.f / (this->sigma * this->sigma);
  }
 
protected:
  float     sigma;  
  glm::vec2 center; 
 
private:
  float inv_sigma2; 
};
 
class RectangleFunction : public Function
{
public:
  RectangleFunction(float     rx,
                    float     ry,
                    float     angle,
                    float     slope,
                    glm::vec2 center);
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  float     rx, ry; 
  float     angle;  
  float     slope;  
  glm::vec2 center; 
 
private:
  float ca; 
  float sa; 
};
 
class RiftFunction : public Function
{
public:
  RiftFunction(float     angle,
               float     slope,
               float     width,
               bool      sharp_bottom,
               glm::vec2 center);
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  float     angle;        
  float     slope;        
  float     width;        
  bool      sharp_bottom; 
  glm::vec2 center;       
 
private:
  float ca; 
  float sa; 
};
 
class SlopeFunction : public Function
{
public:
  SlopeFunction(float angle, float slope, glm::vec2 center);
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  float     angle;  
  float     slope;  
  glm::vec2 center; 
 
private:
  float ca; 
  float sa; 
};
 
class StepFunction : public Function
{
public:
  StepFunction(float angle, float slope, glm::vec2 center);
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  float     angle;  
  float     slope;  
  glm::vec2 center; 
 
private:
  float ca; 
  float sa; 
};
 
class WaveDuneFunction : public Function
{
public:
  WaveDuneFunction(glm::vec2 kw,
                   float     angle,
                   float     xtop,
                   float     xbottom,
                   float     phase_shift,
                   glm::vec2 center = {0.5f, 0.5f});
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  glm::vec2 kw;    
  float     angle; 
  float xtop; 
  float xbottom; 
  float     phase_shift; 
  glm::vec2 center;      
 
private:
  float ca; 
  float sa; 
};
 
class WaveSineFunction : public Function
{
public:
  WaveSineFunction(glm::vec2 kw,
                   float     angle,
                   float     phase_shift,
                   glm::vec2 center = {0.5f, 0.5f});
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  glm::vec2 kw;          
  float     angle;       
  float     phase_shift; 
  glm::vec2 center;      
 
private:
  float ca; 
  float sa; 
};
 
class WaveSquareFunction : public Function
{
public:
  WaveSquareFunction(glm::vec2 kw,
                     float     angle,
                     float     phase_shift,
                     glm::vec2 center = {0.5f, 0.5f});
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  glm::vec2 kw;          
  float     angle;       
  float     phase_shift; 
  glm::vec2 center;      
 
private:
  float ca; 
  float sa; 
};
 
class WaveTriangularFunction : public Function
{
public:
  WaveTriangularFunction(glm::vec2 kw,
                         float     angle,
                         float     slant_ratio,
                         float     phase_shift,
                         glm::vec2 center = {0.5f, 0.5f});
 
  void set_angle(float new_angle)
  {
    this->angle = new_angle;
    this->ca = std::cos(angle / 180.f * M_PI);
    this->sa = std::sin(angle / 180.f * M_PI);
  }
 
protected:
  glm::vec2 kw;          
  float     angle;       
  float     slant_ratio; 
  float     phase_shift; 
  glm::vec2 center;      
 
private:
  float ca; 
  float sa; 
};
 
//----------------------------------------
// NoiseFunction class and derived
//----------------------------------------
 
class NoiseFunction : public Function
{
public:
  NoiseFunction() : Function(), kw(glm::vec2(0.f, 0.f)), seed(0)
  {
  }
 
  NoiseFunction(glm::vec2 kw) : Function(), kw(kw), seed(0)
  {
  }
 
  NoiseFunction(glm::vec2 kw, std::uint32_t seed)
      : Function(), kw(kw), seed(seed)
  {
  }
 
  glm::vec2 get_kw() const
  {
    return this->kw;
  }
 
  std::uint32_t get_seed() const
  {
    return this->seed;
  }
 
  virtual void set_seed(std::uint32_t new_seed)
  {
    this->seed = new_seed;
  }
 
  virtual void set_kw(glm::vec2 new_kw)
  {
    this->kw = new_kw;
  }
 
protected:
  glm::vec2     kw;   
  std::uint32_t seed; 
};
 
//----------------------------------------
// Actual functions
//----------------------------------------
 
class ParberryFunction : public NoiseFunction
{
public:
  float mu;
 
  ParberryFunction(glm::vec2 kw, std::uint32_t seed, float mu);
 
  void initialize();
 
  void set_seed(std::uint32_t /*new_seed*/)
  {
    // FIX ME seed cannot be changed with current implemtantion.
  }
 
private:
  int perlin_b = 0X100;
 
  int perlin_bm = 0xff;
 
  int perlin_n = 0x100;
 
  std::vector<int> p;
 
  std::vector<std::vector<float>> g2;
 
  std::vector<float> m;
};
 
class PerlinFunction : public NoiseFunction
{
public:
  PerlinFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinBillowFunction : public NoiseFunction
{
public:
  PerlinBillowFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinHalfFunction : public NoiseFunction
{
public:
  float k;
 
  PerlinHalfFunction(glm::vec2 kw, std::uint32_t seed, float k);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinMixFunction : public NoiseFunction
{
public:
  PerlinMixFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class Simplex2Function : public NoiseFunction
{
public:
  Simplex2Function(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class Simplex2SFunction : public NoiseFunction
{
public:
  Simplex2SFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueNoiseFunction : public NoiseFunction
{
public:
  ValueNoiseFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueCubicNoiseFunction : public NoiseFunction
{
public:
  ValueCubicNoiseFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueDelaunayNoiseFunction : public NoiseFunction
{
public:
  ValueDelaunayNoiseFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_kw(glm::vec2 new_kw)
  {
    NoiseFunction::set_kw(new_kw);
    this->update_interpolation_function();
  }
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->update_interpolation_function();
  }
 
  void update_interpolation_function();
};
 
class ValueLinearNoiseFunction : public NoiseFunction
{
public:
  ValueLinearNoiseFunction(glm::vec2 kw, std::uint32_t seed);
 
  void set_kw(glm::vec2 new_kw)
  {
    NoiseFunction::set_kw(new_kw);
    this->update_interpolation_function();
  }
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->update_interpolation_function();
  }
 
  void update_interpolation_function();
};
 
class WorleyFunction : public NoiseFunction
{
public:
  WorleyFunction(glm::vec2     kw,
                 std::uint32_t seed,
                 bool          return_cell_value = false);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class WorleyDoubleFunction : public NoiseFunction
{
public:
  float ratio;
 
  float k;
 
  WorleyDoubleFunction(glm::vec2 kw, std::uint32_t seed, float ratio, float k);
 
  void set_seed(std::uint32_t new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise1.SetSeed(new_seed);
    this->noise2.SetSeed(new_seed + 1);
  }
 
private:
  FastNoiseLite noise1, noise2;
};
 
//----------------------------------------
// Composite functions
//----------------------------------------
 
class GenericFractalFunction : public NoiseFunction
{
public:
  explicit GenericFractalFunction(std::unique_ptr<NoiseFunction> p_base,
                                  int                            octaves,
                                  float                          weight,
                                  float                          persistence,
                                  float                          lacunarity);
 
  void set_kw(glm::vec2 new_kw) override
  {
    NoiseFunction::set_kw(new_kw);
    this->p_base->set_kw(new_kw);
  }
 
  void set_lacunarity(float new_lacunarity)
  {
    this->lacunarity = new_lacunarity;
  }
 
  void set_octaves(int new_octaves)
  {
    this->octaves = new_octaves;
    this->update_amp0();
  }
 
  void set_persistence(float new_persistence)
  {
    this->persistence = new_persistence;
    this->update_amp0();
  }
 
  void set_seed(std::uint32_t new_seed) override
  {
    NoiseFunction::set_seed(new_seed);
    this->p_base->set_seed(new_seed);
  }
 
  void scale_amp0(float scale)
  {
    this->amp0 *= scale;
  }
 
  float get_lacunarity() const
  {
    return this->lacunarity;
  }
 
  int get_octaves() const
  {
    return this->octaves;
  }
 
  float get_persistence() const
  {
    return this->persistence;
  }
 
  float get_weight() const
  {
    return this->weight;
  }
 
protected:
  void update_amp0();
 
protected:
  std::unique_ptr<NoiseFunction>
        p_base;      
  int   octaves;     
  float weight;      
  float persistence; 
  float lacunarity;  
  float amp0;        
};
 
class FbmFunction : public GenericFractalFunction
{
public:
  FbmFunction(std::unique_ptr<NoiseFunction> p_base,
              int                            octaves,
              float                          weight,
              float                          persistence,
              float                          lacunarity);
};
class FbmIqFunction : public GenericFractalFunction
{
public:
  FbmIqFunction(std::unique_ptr<NoiseFunction> p_base,
                int                            octaves,
                float                          weight,
                float                          persistence,
                float                          lacunarity,
                float                          gradient_scale);
 
  void set_gradient_scale(float new_gradient_scale)
  {
    this->gradient_scale = new_gradient_scale;
  }
 
protected:
  float gradient_scale; 
};
 
class FbmJordanFunction : public GenericFractalFunction
{
public:
  FbmJordanFunction(std::unique_ptr<NoiseFunction> p_base,
                    int                            octaves,
                    float                          weight,
                    float                          persistence,
                    float                          lacunarity,
                    float                          warp0,
                    float                          damp0,
                    float                          warp_scale,
                    float                          damp_scale);
 
  void set_warp0(float new_warp0)
  {
    this->warp0 = new_warp0;
  }
 
  void set_damp0(float new_damp0)
  {
    this->damp0 = new_damp0;
  }
 
  void set_warp_scale(float new_warp_scale)
  {
    this->warp_scale = new_warp_scale;
  }
 
  void set_damp_scale(float new_damp_scale)
  {
    this->damp_scale = new_damp_scale;
  }
 
protected:
  float warp0;      
  float damp0;      
  float warp_scale; 
  float damp_scale; 
};
 
class FbmPingpongFunction : public GenericFractalFunction
{
public:
  FbmPingpongFunction(std::unique_ptr<NoiseFunction> p_base,
                      int                            octaves,
                      float                          weight,
                      float                          persistence,
                      float                          lacunarity);
 
  void set_k_smoothing(float new_k_smoothing)
  {
    this->k_smoothing = new_k_smoothing;
  }
 
protected:
  float k_smoothing; 
};
 
class FbmRidgedFunction : public GenericFractalFunction
{
public:
  FbmRidgedFunction(std::unique_ptr<NoiseFunction> p_base,
                    int                            octaves,
                    float                          weight,
                    float                          persistence,
                    float                          lacunarity,
                    float                          k_smoothing);
 
  void set_k_smoothing(float new_k_smoothing)
  {
    this->k_smoothing = new_k_smoothing;
  }
 
protected:
  float k_smoothing; 
};
 
class FbmSwissFunction : public GenericFractalFunction
{
public:
  FbmSwissFunction(std::unique_ptr<NoiseFunction> p_base,
                   int                            octaves,
                   float                          weight,
                   float                          persistence,
                   float                          lacunarity,
                   float                          warp_scale);
 
  void set_warp_scale(float new_warp_scale)
  {
    this->warp_scale = new_warp_scale;
    this->warp_scale_normalized = new_warp_scale / this->kw.x;
  }
 
protected:
  float warp_scale;            
  float warp_scale_normalized; 
};
 
//----------------------------------------
// Field functions
//----------------------------------------
 
class FieldFunction : public Function
{
public:
  FieldFunction(std::unique_ptr<Function> p_base);
 
  FieldFunction(std::unique_ptr<Function> p_base,
                std::vector<float>        xr,
                std::vector<float>        yr,
                std::vector<float>        zr);
 
  void set_xr(std::vector<float> new_xr)
  {
    this->xr = new_xr;
  }
 
  void set_yr(std::vector<float> new_yr)
  {
    this->yr = new_yr;
  }
 
  void set_zr(std::vector<float> new_zr)
  {
    this->zr = new_zr;
  }
 
protected:
  std::vector<float> xr; 
  std::vector<float> yr; 
  std::vector<float>
      zr; 
 
private:
  std::unique_ptr<Function> p_base; 
 
  void setup_delegate();
};
 
//----------------------------------------
// Helpers
//----------------------------------------
 
std::unique_ptr<hmap::NoiseFunction> create_noise_function_from_type(
    NoiseType     noise_type,
    glm::vec2     kw,
    std::uint32_t seed);
 
} // namespace hmap