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 <functional>
 
#include "FastNoiseLite.h"
#include "macrologger.h"
 
#include "highmap/array.hpp"
#include "highmap/math.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 Vec4<float> &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, Vec2<float> kw, bool periodic = true);
 
  void set_array(Array new_array)
  {
    this->array = new_array;
  }
 
protected:
  Vec2<float> kw; 
  bool periodic;  
 
private:
  Array array; 
};
 
class BiquadFunction : public Function
{
public:
  BiquadFunction(float gain, Vec2<float> center);
 
protected:
  float       gain;   
  Vec2<float> center; 
};
 
class BumpFunction : public Function
{
public:
  BumpFunction(float gain, Vec2<float> center);
 
protected:
  float       gain;   
  Vec2<float> center; 
};
 
class CraterFunction : public Function
{
public:
  CraterFunction(float       radius,
                 float       depth,
                 float       lip_decay,
                 float       lip_height_ratio,
                 Vec2<float> center);
 
protected:
  float       radius;           
  float       depth;            
  float       lip_decay;        
  float       lip_height_ratio; 
  Vec2<float> center;           
};
 
class DiskFunction : public Function
{
public:
  DiskFunction(float radius, float slope, Vec2<float> center);
 
protected:
  float       radius; 
  float       slope;  
  Vec2<float> center; 
};
 
class GaussianPulseFunction : public Function
{
public:
  GaussianPulseFunction(float sigma, Vec2<float> center);
 
  void set_sigma(float new_sigma)
  {
    this->sigma = new_sigma;
    this->inv_sigma2 = 1.f / (this->sigma * this->sigma);
  }
 
protected:
  float       sigma;  
  Vec2<float> center; 
 
private:
  float inv_sigma2; 
};
 
class RectangleFunction : public Function
{
public:
  RectangleFunction(float       rx,
                    float       ry,
                    float       angle,
                    float       slope,
                    Vec2<float> 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;  
  Vec2<float> center; 
 
private:
  float ca; 
  float sa; 
};
 
class RiftFunction : public Function
{
public:
  RiftFunction(float       angle,
               float       slope,
               float       width,
               bool        sharp_bottom,
               Vec2<float> 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; 
  Vec2<float> center;       
 
private:
  float ca; 
  float sa; 
};
 
class SlopeFunction : public Function
{
public:
  SlopeFunction(float angle, float slope, Vec2<float> 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;  
  Vec2<float> center; 
 
private:
  float ca; 
  float sa; 
};
 
class StepFunction : public Function
{
public:
  StepFunction(float angle, float slope, Vec2<float> 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;  
  Vec2<float> center; 
 
private:
  float ca; 
  float sa; 
};
 
class WaveDuneFunction : public Function
{
public:
  WaveDuneFunction(Vec2<float> kw,
                   float       angle,
                   float       xtop,
                   float       xbottom,
                   float       phase_shift);
 
  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:
  Vec2<float> kw;    
  float       angle; 
  float xtop; 
  float xbottom; 
  float phase_shift; 
 
private:
  float ca; 
  float sa; 
};
 
class WaveSineFunction : public Function
{
public:
  WaveSineFunction(Vec2<float> kw, float angle, float phase_shift);
 
  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:
  Vec2<float> kw;          
  float       angle;       
  float       phase_shift; 
 
private:
  float ca; 
  float sa; 
};
 
class WaveSquareFunction : public Function
{
public:
  WaveSquareFunction(Vec2<float> kw, float angle, float phase_shift);
 
  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:
  Vec2<float> kw;          
  float       angle;       
  float       phase_shift; 
 
private:
  float ca; 
  float sa; 
};
 
class WaveTriangularFunction : public Function
{
public:
  WaveTriangularFunction(Vec2<float> kw,
                         float       angle,
                         float       slant_ratio,
                         float       phase_shift);
 
  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:
  Vec2<float> kw;    
  float       angle; 
  float slant_ratio; 
  float phase_shift; 
 
private:
  float ca; 
  float sa; 
};
 
//----------------------------------------
// NoiseFunction class and derived
//----------------------------------------
 
class NoiseFunction : public Function
{
public:
  NoiseFunction() : Function(), kw(Vec2<float>(0.f, 0.f)), seed(0)
  {
  }
 
  NoiseFunction(Vec2<float> kw) : Function(), kw(kw), seed(0)
  {
  }
 
  NoiseFunction(Vec2<float> kw, uint seed) : Function(), kw(kw), seed(seed)
  {
  }
 
  Vec2<float> get_kw() const
  {
    return this->kw;
  }
 
  uint get_seed() const
  {
    return this->seed;
  }
 
  virtual void set_seed(uint new_seed)
  {
    this->seed = new_seed;
  }
 
  virtual void set_kw(Vec2<float> new_kw)
  {
    this->kw = new_kw;
  }
 
protected:
  Vec2<float> kw;   
  uint        seed; 
};
 
//----------------------------------------
// Actual functions
//----------------------------------------
 
class ParberryFunction : public NoiseFunction
{
public:
  float mu;
 
  ParberryFunction(Vec2<float> kw, uint seed, float mu);
 
  void initialize();
 
  void set_seed(uint /*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(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinBillowFunction : public NoiseFunction
{
public:
  PerlinBillowFunction(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinHalfFunction : public NoiseFunction
{
public:
  float k;
 
  PerlinHalfFunction(Vec2<float> kw, uint seed, float k);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class PerlinMixFunction : public NoiseFunction
{
public:
  PerlinMixFunction(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class Simplex2Function : public NoiseFunction
{
public:
  Simplex2Function(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class Simplex2SFunction : public NoiseFunction
{
public:
  Simplex2SFunction(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueNoiseFunction : public NoiseFunction
{
public:
  ValueNoiseFunction(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueCubicNoiseFunction : public NoiseFunction
{
public:
  ValueCubicNoiseFunction(Vec2<float> kw, uint seed);
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->noise.SetSeed(new_seed);
  }
 
private:
  FastNoiseLite noise;
};
 
class ValueDelaunayNoiseFunction : public NoiseFunction
{
public:
  ValueDelaunayNoiseFunction(Vec2<float> kw, uint seed);
 
  void set_kw(Vec2<float> new_kw)
  {
    NoiseFunction::set_kw(new_kw);
    this->update_interpolation_function();
  }
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->update_interpolation_function();
  }
 
  void update_interpolation_function();
};
 
class ValueLinearNoiseFunction : public NoiseFunction
{
public:
  ValueLinearNoiseFunction(Vec2<float> kw, uint seed);
 
  void set_kw(Vec2<float> new_kw)
  {
    NoiseFunction::set_kw(new_kw);
    this->update_interpolation_function();
  }
 
  void set_seed(uint new_seed)
  {
    NoiseFunction::set_seed(new_seed);
    this->update_interpolation_function();
  }
 
  void update_interpolation_function();
};
 
class WorleyFunction : public NoiseFunction
{
public:
  WorleyFunction(Vec2<float> kw, uint seed, bool return_cell_value = false);
 
  void set_seed(uint 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(Vec2<float> kw, uint seed, float ratio, float k);
 
  void set_seed(uint 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(Vec2<float> 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(uint 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,
    Vec2<float> kw,
    uint        seed);
 
} // namespace hmap