Noises.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_NOISES_H
#define GF_NOISES_H
 
#include <cstddef>
#include <cstdint>
#include <array>
#include <functional>
#include <vector>
 
#include "CoreApi.h"
#include "Math.h"
#include "Noise.h"
#include "Vector.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
 
  class Random;
 
  class GF_CORE_API ValueNoise2D : public Noise2D {
  public:
    ValueNoise2D(Random& random, Step<double> step);
 
    double getValue(double x, double y) override;
 
  private:
    Step<double> m_step;
    std::array<uint8_t, 256> m_perm;
    std::array<double, 256> m_values;
 
    double at(uint8_t i, uint8_t j) const;
  };
 
 
  class GF_CORE_API GradientNoise2D : public Noise2D {
  public:
    GradientNoise2D(Random& random, Step<double> step);
 
    double getValue(double x, double y) override;
 
  private:
    Step<double> m_step;
    std::array<uint8_t, 256> m_perm;
    std::array<Vector2d, 256> m_gradients2D;
 
    const Vector2d& at(uint8_t i, uint8_t j) const;
  };
 
  class GF_CORE_API GradientNoise3D : public Noise3D {
  public:
    GradientNoise3D(Random& random, Step<double> step);
 
    double getValue(double x, double y, double z) override;
 
  private:
    Step<double> m_step;
    std::array<uint8_t, 256> m_perm;
    std::array<Vector3d, 256> m_gradients3D;
 
    const Vector3d& at(uint8_t i, uint8_t j, uint8_t k) const;
  };
 
  class GF_CORE_API BetterGradientNoise2D : public Noise2D {
  public:
    BetterGradientNoise2D(Random& random);
 
    double getValue(double x, double y) override;
 
  private:
    std::array<uint8_t, 256> m_permX;
    std::array<uint8_t, 256> m_permY;
    std::array<Vector2d, 256> m_gradients2D;
 
    const Vector2d& at(uint8_t i, uint8_t j) const;
  };
 
  class GF_CORE_API FractalNoise2D : public Noise2D {
  public:
    FractalNoise2D(Noise2D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double
    dimension = 1.0);
 
    double getValue(double x, double y) override;
 
  private:
    Noise2D& m_noise;
    double m_scale;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
 
  class GF_CORE_API FractalNoise3D : public Noise3D {
  public:
    FractalNoise3D(Noise3D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
 
    double getValue(double x, double y, double z) override;
 
  private:
    Noise3D& m_noise;
    double m_scale;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
 
  class GF_CORE_API PerlinNoise2D : public Noise2D {
  public:
    PerlinNoise2D(Random& random, double scale, std::size_t octaves = 8);
 
    double getValue(double x, double y) override;
 
  private:
    GradientNoise2D m_gradient;
    FractalNoise2D m_fractal;
  };
 
  class GF_CORE_API PerlinNoise3D : public Noise3D {
  public:
    PerlinNoise3D(Random& random, double scale, std::size_t octaves = 8);
 
    double getValue(double x, double y, double z) override;
 
  private:
    GradientNoise3D m_gradient;
    FractalNoise3D m_fractal;
  };
 
 
  class GF_CORE_API SimplexNoise2D : public Noise2D {
  public:
    SimplexNoise2D(Random& random);
 
    double getValue(double x, double y) override;
 
  private:
    std::array<uint8_t, 256> m_perm;
 
    const Vector2d& at(uint8_t i, uint8_t j) const;
  };
 
  enum class OpenSimplexType {
    Super,
    Fast,
  };
 
  enum class OpenSimplex2DVariant {
    Classic,
    XBeforeY,
  };
 
  enum class OpenSimplex3DVariant {
    Classic,
    XYBeforeZ,
    XZBeforeY,
  };
 
  class GF_CORE_API OpenSimplexNoise2D : public Noise2D {
  public:
    OpenSimplexNoise2D(Random& random, OpenSimplexType type = OpenSimplexType::Super, OpenSimplex2DVariant variant = OpenSimplex2DVariant::Classic);
 
    void setType(OpenSimplexType type) {
      m_type = type;
    }
 
    OpenSimplexType getType() const {
      return m_type;
    }
 
    void setVariant(OpenSimplex2DVariant variant) {
      m_variant = variant;
    }
 
    OpenSimplex2DVariant getVariant() const {
      return m_variant;
    }
 
    double getValue(double x, double y) override;
 
  private:
    double getValueBase(double xs, double ys) const;
 
  private:
    OpenSimplexType m_type;
    OpenSimplex2DVariant m_variant;
    std::array<uint16_t, 2048> m_perm;
    std::array<Vector2d, 2048> m_gradients2D;
  };
 
  class GF_CORE_API OpenSimplexNoise3D : public Noise3D {
  public:
    OpenSimplexNoise3D(Random& random, OpenSimplexType type = OpenSimplexType::Super, OpenSimplex3DVariant variant = OpenSimplex3DVariant::Classic);
 
    double getValue(double x, double y, double z) override;
 
  private:
    double getValueBase(double xr, double yr, double zr) const;
 
  private:
    OpenSimplexType m_type;
    OpenSimplex3DVariant m_variant;
    std::array<uint16_t, 2048> m_perm;
    std::array<Vector3d, 2048> m_gradients3D;
  };
 
  class GF_CORE_API WaveletNoise3D : public Noise3D {
  public:
    WaveletNoise3D(Random& random, std::ptrdiff_t n = 32);
 
    double getValue(double x, double y, double z) override;
 
  private:
    std::ptrdiff_t m_n;
    std::vector<double> m_data;
  };
 
  class GF_CORE_API WorleyNoise2D : public Noise2D {
  public:
    WorleyNoise2D(Random& random, std::size_t count, Distance2<double> distance, std::vector<double> coeffs);
 
    double getValue(double x, double y) override;
 
  private:
    std::size_t m_count;
    Distance2<double> m_distance;
    std::vector<double> m_coeffs;
    std::vector<Vector2d> m_cells;
  };
 
 
  class GF_CORE_API Multifractal2D : public Noise2D {
  public:
    Multifractal2D(Noise2D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
 
    double getValue(double x, double y) override;
 
  private:
    Noise2D& m_noise;
    double m_scale;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
 
  class GF_CORE_API HeteroTerrain2D : public Noise2D {
  public:
    HeteroTerrain2D(Noise2D& noise, double scale, double offset = 0.0, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
 
    double getValue(double x, double y) override;
 
  private:
    Noise2D& m_noise;
    double m_scale;
    double m_offset;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
  class GF_CORE_API HybridMultifractal2D : public Noise2D {
  public:
    HybridMultifractal2D(Noise2D& noise, double scale, double offset = 0.0, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
 
    double getValue(double x, double y) override;
 
  private:
    Noise2D& m_noise;
    double m_scale;
    double m_offset;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
  class GF_CORE_API RidgedMultifractal2D : public Noise2D {
  public:
    RidgedMultifractal2D(Noise2D& noise, double scale, double offset = 1.0, double gain = 1.0, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
 
    double getValue(double x, double y) override;
 
  private:
    Noise2D& m_noise;
    double m_scale;
    double m_offset;
    double m_gain;
    std::size_t m_octaves;
    double m_lacunarity;
    double m_persistence;
    double m_dimension;
  };
 
  class GF_CORE_API Noise3DTo2DAdapter : public Noise2D {
  public:
    Noise3DTo2DAdapter(Noise3D& noise, Vector3d normal = Vector3d(0.0, 0.0, 1.0), Vector3d point = Vector3d(0.0, 0.0, 0.0));
 
    double getValue(double x, double y) override;
 
  private:
    Noise3D& m_noise;
    Vector3d m_normal;
    Vector3d m_point;
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_NOISES_H