1 // stb_perlin.h - v0.4 - perlin noise
2 // public domain single-file C implementation by Sean Barrett
3 //
4 // LICENSE
5 //
6 // See end of file.
7 //
8 //
9 // to create the implementation,
10 // #define STB_PERLIN_IMPLEMENTATION
11 // in *one* C/CPP file that includes this file.
12 //
13 //
14 // Documentation:
15 //
16 // float stb_perlin_noise3( float x,
17 // float y,
18 // float z,
19 // int x_wrap=0,
20 // int y_wrap=0,
21 // int z_wrap=0)
22 //
23 // This function computes a random value at the coordinate (x,y,z).
24 // Adjacent random values are continuous but the noise fluctuates
25 // its randomness with period 1, i.e. takes on wholly unrelated values
26 // at integer points. Specifically, this implements Ken Perlin's
27 // revised noise function from 2002.
28 //
29 // The "wrap" parameters can be used to create wraparound noise that
30 // wraps at powers of two. The numbers MUST be powers of two. Specify
31 // 0 to mean "don't care". (The noise always wraps every 256 due
32 // details of the implementation, even if you ask for larger or no
33 // wrapping.)
34 //
35 // float stb_perlin_noise3_seed( float x,
36 // float y,
37 // float z,
38 // int x_wrap=0,
39 // int y_wrap=0,
40 // int z_wrap=0,
41 // int seed)
42 //
43 // As above, but 'seed' selects from multiple different variations of the
44 // noise function. The current implementation only uses the bottom 8 bits
45 // of 'seed', but possibly in the future more bits will be used.
46 //
47 //
48 // Fractal Noise:
49 //
50 // Three common fractal noise functions are included, which produce
51 // a wide variety of nice effects depending on the parameters
52 // provided. Note that each function will call stb_perlin_noise3
53 // 'octaves' times, so this parameter will affect runtime.
54 //
55 // float stb_perlin_ridge_noise3(float x, float y, float z,
56 // float lacunarity, float gain, float offset, int octaves)
57 //
58 // float stb_perlin_fbm_noise3(float x, float y, float z,
59 // float lacunarity, float gain, int octaves)
60 //
61 // float stb_perlin_turbulence_noise3(float x, float y, float z,
62 // float lacunarity, float gain, int octaves)
63 //
64 // Typical values to start playing with:
65 // octaves = 6 -- number of "octaves" of noise3() to sum
66 // lacunarity = ~ 2.0 -- spacing between successive octaves (use exactly 2.0 for wrapping output)
67 // gain = 0.5 -- relative weighting applied to each successive octave
68 // offset = 1.0? -- used to invert the ridges, may need to be larger, not sure
69 //
70 //
71 // Contributors:
72 // Jack Mott - additional noise functions
73 // Jordan Peck - seeded noise
74 //
75
76
77 #ifdef __cplusplus
78 extern "C" {
79 #endif
80 extern float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap);
81 extern float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves);
82 extern float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves);
83 extern float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves);
84 #ifdef __cplusplus
85 }
86 #endif
87
88 #ifdef STB_PERLIN_IMPLEMENTATION
89
90 #include <math.h> // fabs()
91
92 // not same permutation table as Perlin's reference to avoid copyright issues;
93 // Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/
94 static unsigned char stb__perlin_randtab[512] =
95 {
96 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
97 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
98 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
99 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
100 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
101 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
102 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
103 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
104 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
105 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
106 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
107 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
108 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
109 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
110 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
111 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
112
113 // and a second copy so we don't need an extra mask or static initializer
114 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
115 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
116 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
117 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
118 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
119 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
120 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
121 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
122 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
123 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
124 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
125 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
126 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
127 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
128 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
129 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
130 };
131
132
133 // perlin's gradient has 12 cases so some get used 1/16th of the time
134 // and some 2/16ths. We reduce bias by changing those fractions
135 // to 5/64ths and 6/64ths
136
137 // this array is designed to match the previous implementation
138 // of gradient hash: indices[stb__perlin_randtab[i]&63]
139 static unsigned char stb__perlin_randtab_grad_idx[512] =
140 {
141 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7,
142 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8,
143 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8,
144 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5,
145 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1,
146 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4,
147 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11,
148 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6,
149 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0,
150 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2,
151 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3,
152 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11,
153 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1,
154 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10,
155 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7,
156 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5,
157
158 // and a second copy so we don't need an extra mask or static initializer
159 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7,
160 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8,
161 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8,
162 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5,
163 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1,
164 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4,
165 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11,
166 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6,
167 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0,
168 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2,
169 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3,
170 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11,
171 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1,
172 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10,
173 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7,
174 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5,
175 };
176
stb__perlin_lerp(float a,float b,float t)177 static float stb__perlin_lerp(float a, float b, float t)
178 {
179 return a + (b-a) * t;
180 }
181
stb__perlin_fastfloor(float a)182 static int stb__perlin_fastfloor(float a)
183 {
184 int ai = (int) a;
185 return (a < ai) ? ai-1 : ai;
186 }
187
188 // different grad function from Perlin's, but easy to modify to match reference
stb__perlin_grad(int grad_idx,float x,float y,float z)189 static float stb__perlin_grad(int grad_idx, float x, float y, float z)
190 {
191 static float basis[12][4] =
192 {
193 { 1, 1, 0 },
194 { -1, 1, 0 },
195 { 1,-1, 0 },
196 { -1,-1, 0 },
197 { 1, 0, 1 },
198 { -1, 0, 1 },
199 { 1, 0,-1 },
200 { -1, 0,-1 },
201 { 0, 1, 1 },
202 { 0,-1, 1 },
203 { 0, 1,-1 },
204 { 0,-1,-1 },
205 };
206
207 float *grad = basis[grad_idx];
208 return grad[0]*x + grad[1]*y + grad[2]*z;
209 }
210
stb_perlin_noise3_internal(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap,unsigned char seed)211 float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)
212 {
213 float u,v,w;
214 float n000,n001,n010,n011,n100,n101,n110,n111;
215 float n00,n01,n10,n11;
216 float n0,n1;
217
218 unsigned int x_mask = (x_wrap-1) & 255;
219 unsigned int y_mask = (y_wrap-1) & 255;
220 unsigned int z_mask = (z_wrap-1) & 255;
221 int px = stb__perlin_fastfloor(x);
222 int py = stb__perlin_fastfloor(y);
223 int pz = stb__perlin_fastfloor(z);
224 int x0 = px & x_mask, x1 = (px+1) & x_mask;
225 int y0 = py & y_mask, y1 = (py+1) & y_mask;
226 int z0 = pz & z_mask, z1 = (pz+1) & z_mask;
227 int r0,r1, r00,r01,r10,r11;
228
229 #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)
230
231 x -= px; u = stb__perlin_ease(x);
232 y -= py; v = stb__perlin_ease(y);
233 z -= pz; w = stb__perlin_ease(z);
234
235 r0 = stb__perlin_randtab[x0+seed];
236 r1 = stb__perlin_randtab[x1+seed];
237
238 r00 = stb__perlin_randtab[r0+y0];
239 r01 = stb__perlin_randtab[r0+y1];
240 r10 = stb__perlin_randtab[r1+y0];
241 r11 = stb__perlin_randtab[r1+y1];
242
243 n000 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z0], x , y , z );
244 n001 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z1], x , y , z-1 );
245 n010 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z0], x , y-1, z );
246 n011 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z1], x , y-1, z-1 );
247 n100 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z0], x-1, y , z );
248 n101 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z1], x-1, y , z-1 );
249 n110 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z0], x-1, y-1, z );
250 n111 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z1], x-1, y-1, z-1 );
251
252 n00 = stb__perlin_lerp(n000,n001,w);
253 n01 = stb__perlin_lerp(n010,n011,w);
254 n10 = stb__perlin_lerp(n100,n101,w);
255 n11 = stb__perlin_lerp(n110,n111,w);
256
257 n0 = stb__perlin_lerp(n00,n01,v);
258 n1 = stb__perlin_lerp(n10,n11,v);
259
260 return stb__perlin_lerp(n0,n1,u);
261 }
262
stb_perlin_noise3(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap)263 float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)
264 {
265 return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap,0);
266 }
267
stb_perlin_noise3_seed(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap,int seed)268 float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)
269 {
270 return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap, (unsigned char) seed);
271 }
272
stb_perlin_ridge_noise3(float x,float y,float z,float lacunarity,float gain,float offset,int octaves)273 float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)
274 {
275 int i;
276 float frequency = 1.0f;
277 float prev = 1.0f;
278 float amplitude = 0.5f;
279 float sum = 0.0f;
280
281 for (i = 0; i < octaves; i++) {
282 float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i);
283 r = offset - (float) fabs(r);
284 r = r*r;
285 sum += r*amplitude*prev;
286 prev = r;
287 frequency *= lacunarity;
288 amplitude *= gain;
289 }
290 return sum;
291 }
292
stb_perlin_fbm_noise3(float x,float y,float z,float lacunarity,float gain,int octaves)293 float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
294 {
295 int i;
296 float frequency = 1.0f;
297 float amplitude = 1.0f;
298 float sum = 0.0f;
299
300 for (i = 0; i < octaves; i++) {
301 sum += stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
302 frequency *= lacunarity;
303 amplitude *= gain;
304 }
305 return sum;
306 }
307
stb_perlin_turbulence_noise3(float x,float y,float z,float lacunarity,float gain,int octaves)308 float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
309 {
310 int i;
311 float frequency = 1.0f;
312 float amplitude = 1.0f;
313 float sum = 0.0f;
314
315 for (i = 0; i < octaves; i++) {
316 float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
317 sum += (float) fabs(r);
318 frequency *= lacunarity;
319 amplitude *= gain;
320 }
321 return sum;
322 }
323
324 #endif // STB_PERLIN_IMPLEMENTATION
325
326 /*
327 ------------------------------------------------------------------------------
328 This software is available under 2 licenses -- choose whichever you prefer.
329 ------------------------------------------------------------------------------
330 ALTERNATIVE A - MIT License
331 Copyright (c) 2017 Sean Barrett
332 Permission is hereby granted, free of charge, to any person obtaining a copy of
333 this software and associated documentation files (the "Software"), to deal in
334 the Software without restriction, including without limitation the rights to
335 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
336 of the Software, and to permit persons to whom the Software is furnished to do
337 so, subject to the following conditions:
338 The above copyright notice and this permission notice shall be included in all
339 copies or substantial portions of the Software.
340 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
341 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
342 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
343 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
344 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
345 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
346 SOFTWARE.
347 ------------------------------------------------------------------------------
348 ALTERNATIVE B - Public Domain (www.unlicense.org)
349 This is free and unencumbered software released into the public domain.
350 Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
351 software, either in source code form or as a compiled binary, for any purpose,
352 commercial or non-commercial, and by any means.
353 In jurisdictions that recognize copyright laws, the author or authors of this
354 software dedicate any and all copyright interest in the software to the public
355 domain. We make this dedication for the benefit of the public at large and to
356 the detriment of our heirs and successors. We intend this dedication to be an
357 overt act of relinquishment in perpetuity of all present and future rights to
358 this software under copyright law.
359 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
360 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
361 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
362 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
363 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
364 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
365 ------------------------------------------------------------------------------
366 */
367