sandbox
Loading...
Searching...
No Matches
noise.hpp
1#ifndef LIBSBX_MATH_NOISE_HPP_
2#define LIBSBX_MATH_NOISE_HPP_
3
4#include <array>
5#include <cinttypes>
6
7#include <libsbx/math/vector2.hpp>
8#include <libsbx/math/random.hpp>
9#include <libsbx/math/concepts.hpp>
10
11namespace sbx::math {
12
13class noise {
14
15 inline static auto permutation = std::array<std::uint8_t, 256>{
16 151, 160, 137, 91, 90, 15,
17 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
18 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
19 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
20 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244,
21 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196,
22 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123,
23 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
24 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
25 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228,
26 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
27 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
28 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
29 };
30
31 inline static constexpr auto F2 = 0.366025403f;
32 inline static constexpr auto G2 = 0.211324865f;
33
34public:
35
36 static constexpr auto fractal(const std::float_t x, const std::float_t y, std::uint32_t octaves) -> std::float_t {
37 auto output = 0.f;
38 auto denom = 0.f;
39 auto frequency = 1.0f;
40 auto amplitude = 1.0f;
41
42 for (auto i = 0; i < octaves; i++) {
43 output += (amplitude * simplex(x * frequency, y * frequency));
44 denom += amplitude;
45
46 frequency *= 2.0;
47 amplitude *= 0.5;
48 }
49
50 return (output / denom);
51 }
52
53 static constexpr auto fractal(const sbx::math::vector3& vector, std::uint32_t octaves) -> std::float_t {
54 return fractal(vector.x(), vector.y(), vector.z(), octaves);
55 }
56
57 static constexpr auto fractal(const std::float_t x, const std::float_t y, const std::float_t z, std::uint32_t octaves) -> std::float_t {
58 auto output = 0.f;
59 auto denom = 0.f;
60 auto frequency = 1.0f;
61 auto amplitude = 1.0f;
62
63 for (auto i = 0; i < octaves; i++) {
64 output += (amplitude * simplex(x * frequency, y * frequency, z * frequency));
65 denom += amplitude;
66
67 frequency *= 2.0;
68 amplitude *= 0.5;
69 }
70
71 return (output / denom);
72 }
73
74 static constexpr auto simplex(const std::float_t x, const std::float_t y) -> std::float_t {
75 auto n0 = 0.0f;
76 auto n1 = 0.0f;
77 auto n2 = 0.0f;
78
79 const auto s = (x + y) * F2;
80 const auto xs = x + s;
81 const auto ys = y + s;
82 const auto i = fast_floor(xs);
83 const auto j = fast_floor(ys);
84
85 const auto t = static_cast<std::float_t>(i + j) * G2;
86 const auto X0 = i - t;
87 const auto Y0 = j - t;
88 const auto x0 = x - X0;
89 const auto y0 = y - Y0;
90
91 auto i1 = 0;
92 auto j1 = 0;
93
94 if (x0 > y0) {
95 i1 = 1;
96 j1 = 0;
97 } else {
98 i1 = 0;
99 j1 = 1;
100 }
101
102 const auto x1 = x0 - i1 + G2;
103 const auto y1 = y0 - j1 + G2;
104 const auto x2 = x0 - 1.0f + 2.0f * G2;
105 const auto y2 = y0 - 1.0f + 2.0f * G2;
106
107 const auto gi0 = hash(i + hash(j));
108 const auto gi1 = hash(i + i1 + hash(j + j1));
109 const auto gi2 = hash(i + 1 + hash(j + 1));
110
111 auto t0 = 0.5f - x0 * x0 - y0 * y0;
112
113 if (t0 < 0.0f) {
114 n0 = 0.0f;
115 } else {
116 t0 *= t0;
117 n0 = t0 * t0 * grad(gi0, x0, y0);
118 }
119
120 auto t1 = 0.5f - x1 * x1 - y1 * y1;
121
122 if (t1 < 0.0f) {
123 n1 = 0.0f;
124 } else {
125 t1 *= t1;
126 n1 = t1 * t1 * grad(gi1, x1, y1);
127 }
128
129 auto t2 = 0.5f - x2 * x2 - y2 * y2;
130
131 if (t2 < 0.0f) {
132 n2 = 0.0f;
133 } else {
134 t2 *= t2;
135 n2 = t2 * t2 * grad(gi2, x2, y2);
136 }
137
138 return 45.23065f * (n0 + n1 + n2);
139 }
140
141 static constexpr auto simplex(const std::float_t x, const std::float_t y, const std::float_t z) -> std::float_t {
142 float n0, n1, n2, n3; // Noise contributions from the four corners
143
144 // Skewing/Unskewing factors for 3D
145 constexpr float F3 = 1.0f / 3.0f;
146 constexpr float G3 = 1.0f / 6.0f;
147
148 // Skew the input space to determine which simplex cell we're in
149 float s = (x + y + z) * F3; // Very nice and simple skew factor for 3D
150 int i = fast_floor(x + s);
151 int j = fast_floor(y + s);
152 int k = fast_floor(z + s);
153 float t = (i + j + k) * G3;
154 float X0 = i - t; // Unskew the cell origin back to (x,y,z) space
155 float Y0 = j - t;
156 float Z0 = k - t;
157 float x0 = x - X0; // The x,y,z distances from the cell origin
158 float y0 = y - Y0;
159 float z0 = z - Z0;
160
161 // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
162 // Determine which simplex we are in.
163 int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
164 int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
165 if (x0 >= y0) {
166 if (y0 >= z0) {
167 i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; // X Y Z order
168 } else if (x0 >= z0) {
169 i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; // X Z Y order
170 } else {
171 i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; // Z X Y order
172 }
173 } else { // x0<y0
174 if (y0 < z0) {
175 i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; // Z Y X order
176 } else if (x0 < z0) {
177 i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; // Y Z X order
178 } else {
179 i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; // Y X Z order
180 }
181 }
182
183 // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
184 // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
185 // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
186 // c = 1/6.
187 float x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
188 float y1 = y0 - j1 + G3;
189 float z1 = z0 - k1 + G3;
190 float x2 = x0 - i2 + 2.0f * G3; // Offsets for third corner in (x,y,z) coords
191 float y2 = y0 - j2 + 2.0f * G3;
192 float z2 = z0 - k2 + 2.0f * G3;
193 float x3 = x0 - 1.0f + 3.0f * G3; // Offsets for last corner in (x,y,z) coords
194 float y3 = y0 - 1.0f + 3.0f * G3;
195 float z3 = z0 - 1.0f + 3.0f * G3;
196
197 // Work out the hashed gradient indices of the four simplex corners
198 int gi0 = hash(i + hash(j + hash(k)));
199 int gi1 = hash(i + i1 + hash(j + j1 + hash(k + k1)));
200 int gi2 = hash(i + i2 + hash(j + j2 + hash(k + k2)));
201 int gi3 = hash(i + 1 + hash(j + 1 + hash(k + 1)));
202
203 // Calculate the contribution from the four corners
204 float t0 = 0.6f - x0*x0 - y0*y0 - z0*z0;
205 if (t0 < 0) {
206 n0 = 0.0;
207 } else {
208 t0 *= t0;
209 n0 = t0 * t0 * grad(gi0, x0, y0, z0);
210 }
211 float t1 = 0.6f - x1*x1 - y1*y1 - z1*z1;
212 if (t1 < 0) {
213 n1 = 0.0;
214 } else {
215 t1 *= t1;
216 n1 = t1 * t1 * grad(gi1, x1, y1, z1);
217 }
218 float t2 = 0.6f - x2*x2 - y2*y2 - z2*z2;
219 if (t2 < 0) {
220 n2 = 0.0;
221 } else {
222 t2 *= t2;
223 n2 = t2 * t2 * grad(gi2, x2, y2, z2);
224 }
225 float t3 = 0.6f - x3*x3 - y3*y3 - z3*z3;
226 if (t3 < 0) {
227 n3 = 0.0;
228 } else {
229 t3 *= t3;
230 n3 = t3 * t3 * grad(gi3, x3, y3, z3);
231 }
232 // Add contributions from each corner to get the final noise value.
233 // The result is scaled to stay just inside [-1,1]
234 return 32.0f*(n0 + n1 + n2 + n3);
235 }
236
237private:
238
239 static constexpr auto fast_floor(std::float_t fp) -> std::int32_t {
240 auto i = static_cast<std::int32_t>(fp);
241 return (fp < i) ? (i - 1) : (i);
242 }
243
244 static constexpr auto hash(std::int32_t i) -> std::uint8_t {
245 return permutation[static_cast<std::uint8_t>(i)];
246 }
247
248 static constexpr auto grad(std::int32_t hash, std::float_t x, std::float_t y) -> std::float_t {
249 const auto h = hash & 0x3F;
250 const auto u = h < 4 ? x : y;
251 const auto v = h < 4 ? y : x;
252
253 return ((h & 1) ? -u : u) + ((h & 2) ? -2.0f * v : 2.0f * v);
254 }
255
256 static constexpr float grad(int32_t hash, float x, float y, float z) {
257 int h = hash & 15; // Convert low 4 bits of hash code into 12 simple
258 float u = h < 8 ? x : y; // gradient directions, and compute dot product.
259 float v = h < 4 ? y : h == 12 || h == 14 ? x : z; // Fix repeats at h = 12 to 15
260 return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
261 }
262
263}; // class noise
264
265} // namespace sbx::math
266
267#endif // LIBSBX_MATH_NOISE_HPP_
sbx::math::basic_vector3
Definition: vector3.hpp:22
sbx::math::noise
Definition: noise.hpp:13