Noises.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2018 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 "Math.h"
#include "Noise.h"
#include "Portability.h"
#include "Vector.h"


namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  class Random;

  class GF_API ValueNoise2D : public Noise2D {
  public:
    ValueNoise2D(Random& random, Step<double> step);

    virtual 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_API GradientNoise2D : public Noise2D {
  public:
    GradientNoise2D(Random& random, Step<double> step);

    virtual 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_API GradientNoise3D : public Noise3D {
  public:
    GradientNoise3D(Random& random, Step<double> step);

    virtual 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_API BetterGradientNoise2D : public Noise2D {
  public:
    BetterGradientNoise2D(Random& random);

    virtual 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_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);

    virtual 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_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);

    virtual 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_API PerlinNoise2D : public Noise2D {
  public:
    PerlinNoise2D(Random& random, double scale, std::size_t octaves = 8);

    virtual double getValue(double x, double y) override;

  private:
    GradientNoise2D m_gradient;
    FractalNoise2D m_fractal;
  };

  class GF_API PerlinNoise3D : public Noise3D {
  public:
    PerlinNoise3D(Random& random, double scale, std::size_t octaves = 8);

    virtual double getValue(double x, double y, double z) override;

  private:
    GradientNoise3D m_gradient;
    FractalNoise3D m_fractal;
  };


  class GF_API SimplexNoise2D : public Noise2D {
  public:
    SimplexNoise2D(Random& random);

    virtual 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;
  };


  class GF_API OpenSimplexNoise2D : public Noise2D {
  public:
    OpenSimplexNoise2D(Random& random);

    virtual 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;
  };

  class GF_API OpenSimplexNoise3D : public Noise3D {
  public:
    OpenSimplexNoise3D(Random& random);

    virtual double getValue(double x, double y, double z) override;

  private:
    std::array<uint8_t, 256> m_perm;

    const Vector3d& at(uint8_t i, uint8_t j, uint8_t k) const;
  };

  class GF_API WaveletNoise3D : public Noise3D {
  public:
    WaveletNoise3D(Random& random, std::ptrdiff_t n = 32);

    virtual double getValue(double x, double y, double z) override;

  private:
    std::ptrdiff_t m_n;
    std::vector<double> m_data;
  };

  class GF_API WorleyNoise2D : public Noise2D {
  public:
    WorleyNoise2D(Random& random, std::size_t count, Distance2<double> distance, std::vector<double> coeffs);

    virtual 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_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);

    virtual 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_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);

    virtual 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_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);

    virtual 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_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);

    virtual 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_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));

    virtual 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