header_utils
Loading...
Searching...
No Matches
noise.h
1
4
5#pragma once
6
7#include <concepts>
8#include <cstdint>
9
11
12namespace ghassanpl::noise
13{
14
16
17 namespace detail
18 {
19 template <std::floating_point F>
20 constexpr int32_t fastfloor(F fp)
21 {
22 const auto i = static_cast<int32_t>(fp);
23 return (fp < i) ? (i - 1) : i;
24 }
25
26 constexpr inline uint8_t perm[256] = {
27 151, 160, 137, 91, 90, 15,
28 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
29 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
30 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
31 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244,
32 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196,
33 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123,
34 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
35 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
36 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228,
37 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
38 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
39 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
40 };
41
42 constexpr uint8_t hash(int32_t i)
43 {
44 return perm[static_cast<uint8_t>(i)];
45 }
46
47 template <std::floating_point F>
48 constexpr F grad(int32_t hash, F x)
49 {
50 const int32_t h = hash & 0x0F; // Convert low 4 bits of hash code
51 F grad = F(1.0) + (h & 7); // Gradient value 1.0, 2.0, ..., 8.0
52 if ((h & 8) != 0) grad = -grad; // Set a random sign for the gradient
53 return (grad * x); // Multiply the gradient with the distance
54 }
55
56 template <std::floating_point F>
57 constexpr F grad(int32_t hash, F x, F y)
58 {
59 const int32_t h = hash & 0x3F; // Convert low 3 bits of hash code
60 const F u = h < 4 ? x : y; // into 8 simple gradient directions,
61 const F v = h < 4 ? y : x;
62 return ((h & 1) ? -u : u) + ((h & 2) ? F(-2.0) * v : F(2.0) * v); // and compute the dot product with (x,y).
63 }
64
65 template <std::floating_point F>
66 constexpr F grad(int32_t hash, F x, F y, F z)
67 {
68 const int h = hash & 15; // Convert low 4 bits of hash code into 12 simple
69 const F u = h < 8 ? x : y; // gradient directions, and compute dot product.
70 const F v = h < 4 ? y : h == 12 || h == 14 ? x : z; // Fix repeats at h = 12 to 15
71 return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
72 }
73 }
74
75 template <std::floating_point F>
76 constexpr F simplex_noise(F x)
77 {
78 int32_t i0 = detail::fastfloor(x);
79 int32_t i1 = i0 + 1;
80
81 F x0 = x - i0;
82 F x1 = x0 - F(1.0);
83
84 F t0 = F(1.0) - x0 * x0;
85
86 t0 *= t0;
87 F n0 = t0 * t0 * detail::grad(detail::hash(i0), x0);
88
89 F t1 = F(1.0) - x1 * x1;
90
91 t1 *= t1;
92 F n1 = t1 * t1 * detail::grad(detail::hash(i1), x1);
93
94 return F(0.395) * (n0 + n1);
95 }
96
97 template <std::floating_point F>
98 constexpr F simplex_noise(F x, F y)
99 {
100 static constexpr F F2 = F(0.366025403); // F2 = (sqrt(3) - 1) / 2
101 static constexpr F G2 = F(0.211324865); // G2 = (3 - sqrt(3)) / 6 = F2 / (1 + 2 * K)
102
103 const F s = (x + y) * F2;
104 const F xs = x + s;
105 const F ys = y + s;
106 const int32_t i = fastfloor(xs);
107 const int32_t j = fastfloor(ys);
108
109 const F t = static_cast<F>(i + j) * G2;
110 const F X0 = i - t;
111 const F Y0 = j - t;
112 const F x0 = x - X0;
113 const F y0 = y - Y0;
114
115 int32_t i1;
116 int32_t j1;
117 if (x0 > y0) {
118 i1 = 1;
119 j1 = 0;
120 }
121 else {
122 i1 = 0;
123 j1 = 1;
124 }
125
126 const F x1 = x0 - i1 + G2;
127 const F y1 = y0 - j1 + G2;
128 const F x2 = x0 - F(1.0) + F(2.0) * G2;
129 const F y2 = y0 - F(1.0) + F(2.0) * G2;
130
131 const int gi0 = hash(i + hash(j));
132 const int gi1 = hash(i + i1 + hash(j + j1));
133 const int gi2 = hash(i + 1 + hash(j + 1));
134
135 F n0;
136 if (F t0 = F(0.5) - x0 * x0 - y0 * y0; t0 < F(0.0))
137 n0 = F(0.0);
138 else {
139 t0 *= t0;
140 n0 = t0 * t0 * grad(gi0, x0, y0);
141 }
142
143 F n1;
144 if (F t1 = F(0.5) - x1 * x1 - y1 * y1; t1 < F(0.0))
145 n1 = F(0.0);
146 else {
147 t1 *= t1;
148 n1 = t1 * t1 * grad(gi1, x1, y1);
149 }
150
151 F n2;
152 if (F t2 = F(0.5) - x2 * x2 - y2 * y2; t2 < F(0.0))
153 n2 = F(0.0);
154 else {
155 t2 *= t2;
156 n2 = t2 * t2 * grad(gi2, x2, y2);
157 }
158
159 return F(45.23065) * (n0 + n1 + n2);
160 }
161
162 template <std::floating_point F>
163 constexpr F fractal_simplex_noise(size_t octaves, F x, F frequency = F(1.0), F amplitude = F(1.0), F lacunarity = F(2.0), F persistence = F(0.5))
164 {
165 F output = 0;
166 F denom = 0;
167
168 for (size_t i = 0; i < octaves; i++)
169 {
170 output += (amplitude * Noise1D(x * frequency));
171 denom += amplitude;
172
173 frequency *= lacunarity;
174 amplitude *= persistence;
175 }
176
177 return (output / denom);
178 }
179
180 template <std::floating_point F>
181 constexpr F fractal_simplex_noise(size_t octaves, F x, F y, F frequency = F(1.0), F amplitude = F(1.0), F lacunarity = F(2.0), F persistence = F(0.5))
182 {
183 F output = 0;
184 F denom = 0;
185
186 for (size_t i = 0; i < octaves; i++)
187 {
188 output += (amplitude * Noise2D(x * frequency, y * frequency));
189 denom += amplitude;
190
191 frequency *= lacunarity;
192 amplitude *= persistence;
193 }
194
195 return (output / denom);
196 }
197
198}
ghassanpl::bit_count
constexpr auto bit_count
Equal to the number of bits in the type.
Definition bits.h:33
detail
The below code is based on Sun's libm library code, which is licensed under the following license:
Definition constexpr_math.inl:12
ghassanpl::noise
Shamelessly stolen from https://github.com/SRombauts/SimplexNoise/.
Definition noise.h:13