Gamedev Framework (gf)  0.8.0
A C++14 framework for 2D games
Noises.h
1 /*
2  * Gamedev Framework (gf)
3  * Copyright (C) 2016-2018 Julien Bernard
4  *
5  * This software is provided 'as-is', without any express or implied
6  * warranty. In no event will the authors be held liable for any damages
7  * arising from the use of this software.
8  *
9  * Permission is granted to anyone to use this software for any purpose,
10  * including commercial applications, and to alter it and redistribute it
11  * freely, subject to the following restrictions:
12  *
13  * 1. The origin of this software must not be misrepresented; you must not
14  * claim that you wrote the original software. If you use this software
15  * in a product, an acknowledgment in the product documentation would be
16  * appreciated but is not required.
17  * 2. Altered source versions must be plainly marked as such, and must not be
18  * misrepresented as being the original software.
19  * 3. This notice may not be removed or altered from any source distribution.
20  */
21 #ifndef GF_NOISES_H
22 #define GF_NOISES_H
23 
24 #include <cstddef>
25 #include <cstdint>
26 #include <array>
27 #include <functional>
28 #include <vector>
29 
30 #include "Math.h"
31 #include "Noise.h"
32 #include "Portability.h"
33 #include "Vector.h"
34 
35 
36 namespace gf {
37 #ifndef DOXYGEN_SHOULD_SKIP_THIS
38 inline namespace v1 {
39 #endif
40 
41  class Random;
42 
50  class GF_API ValueNoise2D : public Noise2D {
51  public:
60  ValueNoise2D(Random& random, Step<double> step);
61 
62  virtual double getValue(double x, double y) override;
63 
64  private:
65  Step<double> m_step;
66  std::array<uint8_t, 256> m_perm;
67  std::array<double, 256> m_values;
68 
69  double at(uint8_t i, uint8_t j) const;
70  };
71 
72 
80  class GF_API GradientNoise2D : public Noise2D {
81  public:
90  GradientNoise2D(Random& random, Step<double> step);
91 
92  virtual double getValue(double x, double y) override;
93 
94  private:
95  Step<double> m_step;
96  std::array<uint8_t, 256> m_perm;
97  std::array<Vector2d, 256> m_gradients2D;
98 
99  const Vector2d& at(uint8_t i, uint8_t j) const;
100  };
101 
109  class GF_API GradientNoise3D : public Noise3D {
110  public:
119  GradientNoise3D(Random& random, Step<double> step);
120 
121  virtual double getValue(double x, double y, double z) override;
122 
123  private:
124  Step<double> m_step;
125  std::array<uint8_t, 256> m_perm;
126  std::array<Vector3d, 256> m_gradients3D;
127 
128  const Vector3d& at(uint8_t i, uint8_t j, uint8_t k) const;
129  };
130 
141  class GF_API BetterGradientNoise2D : public Noise2D {
142  public:
148  BetterGradientNoise2D(Random& random);
149 
150  virtual double getValue(double x, double y) override;
151 
152  private:
153  std::array<uint8_t, 256> m_permX;
154  std::array<uint8_t, 256> m_permY;
155  std::array<Vector2d, 256> m_gradients2D;
156 
157  const Vector2d& at(uint8_t i, uint8_t j) const;
158  };
159 
168  class GF_API FractalNoise2D : public Noise2D {
169  public:
180  FractalNoise2D(Noise2D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double
181  dimension = 1.0);
182 
183  virtual double getValue(double x, double y) override;
184 
185  private:
186  Noise2D& m_noise;
187  double m_scale;
188  std::size_t m_octaves;
189  double m_lacunarity;
190  double m_persistence;
191  double m_dimension;
192  };
193 
194 
203  class GF_API FractalNoise3D : public Noise3D {
204  public:
215  FractalNoise3D(Noise3D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
216 
217  virtual double getValue(double x, double y, double z) override;
218 
219  private:
220  Noise3D& m_noise;
221  double m_scale;
222  std::size_t m_octaves;
223  double m_lacunarity;
224  double m_persistence;
225  double m_dimension;
226  };
227 
228 
238  class GF_API PerlinNoise2D : public Noise2D {
239  public:
247  PerlinNoise2D(Random& random, double scale, std::size_t octaves = 8);
248 
249  virtual double getValue(double x, double y) override;
250 
251  private:
252  GradientNoise2D m_gradient;
253  FractalNoise2D m_fractal;
254  };
255 
265  class GF_API PerlinNoise3D : public Noise3D {
266  public:
274  PerlinNoise3D(Random& random, double scale, std::size_t octaves = 8);
275 
276  virtual double getValue(double x, double y, double z) override;
277 
278  private:
279  GradientNoise3D m_gradient;
280  FractalNoise3D m_fractal;
281  };
282 
283 
296  class GF_API SimplexNoise2D : public Noise2D {
297  public:
303  SimplexNoise2D(Random& random);
304 
305  virtual double getValue(double x, double y) override;
306 
307  private:
308  std::array<uint8_t, 256> m_perm;
309 
310  const Vector2d& at(uint8_t i, uint8_t j) const;
311  };
312 
313 
323  class GF_API OpenSimplexNoise2D : public Noise2D {
324  public:
330  OpenSimplexNoise2D(Random& random);
331 
332  virtual double getValue(double x, double y) override;
333 
334  private:
335  std::array<uint8_t, 256> m_perm;
336 
337  const Vector2d& at(uint8_t i, uint8_t j) const;
338  };
339 
349  class GF_API OpenSimplexNoise3D : public Noise3D {
350  public:
356  OpenSimplexNoise3D(Random& random);
357 
358  virtual double getValue(double x, double y, double z) override;
359 
360  private:
361  std::array<uint8_t, 256> m_perm;
362 
363  const Vector3d& at(uint8_t i, uint8_t j, uint8_t k) const;
364  };
365 
372  class GF_API WaveletNoise3D : public Noise3D {
373  public:
380  WaveletNoise3D(Random& random, std::ptrdiff_t n = 32);
381 
382  virtual double getValue(double x, double y, double z) override;
383 
384  private:
385  std::ptrdiff_t m_n;
386  std::vector<double> m_data;
387  };
388 
397  class GF_API WorleyNoise2D : public Noise2D {
398  public:
407  WorleyNoise2D(Random& random, std::size_t count, Distance2<double> distance, std::vector<double> coeffs);
408 
409  virtual double getValue(double x, double y) override;
410 
411  private:
412  std::size_t m_count;
413  Distance2<double> m_distance;
414  std::vector<double> m_coeffs;
415  std::vector<Vector2d> m_cells;
416  };
417 
418 
424  class GF_API Multifractal2D : public Noise2D {
425  public:
436  Multifractal2D(Noise2D& noise, double scale, std::size_t octaves = 8, double lacunarity = 2.0, double persistence = 0.5, double dimension = 1.0);
437 
438  virtual double getValue(double x, double y) override;
439 
440  private:
441  Noise2D& m_noise;
442  double m_scale;
443  std::size_t m_octaves;
444  double m_lacunarity;
445  double m_persistence;
446  double m_dimension;
447  };
448 
449 
455  class GF_API HeteroTerrain2D : public Noise2D {
456  public:
468  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);
469 
470  virtual double getValue(double x, double y) override;
471 
472  private:
473  Noise2D& m_noise;
474  double m_scale;
475  double m_offset;
476  std::size_t m_octaves;
477  double m_lacunarity;
478  double m_persistence;
479  double m_dimension;
480  };
481 
487  class GF_API HybridMultifractal2D : public Noise2D {
488  public:
500  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);
501 
502  virtual double getValue(double x, double y) override;
503 
504  private:
505  Noise2D& m_noise;
506  double m_scale;
507  double m_offset;
508  std::size_t m_octaves;
509  double m_lacunarity;
510  double m_persistence;
511  double m_dimension;
512  };
513 
519  class GF_API RidgedMultifractal2D : public Noise2D {
520  public:
533  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);
534 
535  virtual double getValue(double x, double y) override;
536 
537  private:
538  Noise2D& m_noise;
539  double m_scale;
540  double m_offset;
541  double m_gain;
542  std::size_t m_octaves;
543  double m_lacunarity;
544  double m_persistence;
545  double m_dimension;
546  };
547 
558  class GF_API Noise3DTo2DAdapter : public Noise2D {
559  public:
567  Noise3DTo2DAdapter(Noise3D& noise, Vector3d normal = Vector3d(0.0, 0.0, 1.0), Vector3d point = Vector3d(0.0, 0.0, 0.0));
568 
569  virtual double getValue(double x, double y) override;
570 
571  private:
572  Noise3D& m_noise;
573  Vector3d m_normal;
574  Vector3d m_point;
575  };
576 
577 #ifndef DOXYGEN_SHOULD_SKIP_THIS
578 }
579 #endif
580 }
581 
582 #endif // GF_NOISES_H
A random engine.
Definition: Random.h:45
void scale(Matrix3f &mat, Vector2f factor)
Combine the current transform with a scaling.
Distance< T, 2 > Distance2
A distance function for 2D vectors.
Definition: Vector.h:1330
Gradient 3D noise.
Definition: Noises.h:109
Gradient 2D noise.
Definition: Noises.h:80
2D A noise function
Definition: Noise.h:35
3D A noise function
Definition: Noise.h:71
Ridged Multifractal 2D noise.
Definition: Noises.h:519
OpenSimplex3D noise.
Definition: Noises.h:349
OpenSimplex 2D noise.
Definition: Noises.h:323
Worley 2D noise.
Definition: Noises.h:397
The namespace for gf classes.
Definition: Action.h:34
Perlin 2D noise.
Definition: Noises.h:238
Perlin 3D noise.
Definition: Noises.h:265
Fractal 3D noise.
Definition: Noises.h:203
Fractal 2D noise.
Definition: Noises.h:168
Wavelet 3D noise.
Definition: Noises.h:372
An adapter that make a 2D noise from a 3D noise.
Definition: Noises.h:558
Value 2D noise.
Definition: Noises.h:50
T(*)(T) Step
A step is a function with special features.
Definition: Math.h:153
Hybrid Multifractal 2D noise.
Definition: Noises.h:487
Simplex 2D noise.
Definition: Noises.h:296
General purpose math vector.
Definition: Vector.h:61
Better gradient 2D noise.
Definition: Noises.h:141
Multi Fractal 2D noise.
Definition: Noises.h:424
Vector< double, 3 > Vector3d
A double vector with 3 components.
Definition: Vector.h:1139
Hetero Terrain 2D noise.
Definition: Noises.h:455