1 // stb_perlin.h - v0.5 - 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_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed);
82 extern float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves);
83 extern float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves);
84 extern float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves);
85 extern float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed);
86 #ifdef __cplusplus
87 }
88 #endif
89
90 #ifdef STB_PERLIN_IMPLEMENTATION
91
92 #include <math.h> // fabs()
93
94 // not same permutation table as Perlin's reference to avoid copyright issues;
95 // Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/
96 static unsigned char stb__perlin_randtab[512] =
97 {
98 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
99 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
100 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
101 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
102 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
103 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
104 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
105 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
106 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
107 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
108 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
109 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
110 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
111 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
112 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
113 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
114
115 // and a second copy so we don't need an extra mask or static initializer
116 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
117 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
118 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
119 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
120 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
121 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
122 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
123 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
124 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
125 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
126 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
127 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
128 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
129 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
130 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
131 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
132 };
133
134
135 // perlin's gradient has 12 cases so some get used 1/16th of the time
136 // and some 2/16ths. We reduce bias by changing those fractions
137 // to 5/64ths and 6/64ths
138
139 // this array is designed to match the previous implementation
140 // of gradient hash: indices[stb__perlin_randtab[i]&63]
141 static unsigned char stb__perlin_randtab_grad_idx[512] =
142 {
143 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7,
144 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8,
145 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8,
146 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5,
147 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1,
148 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4,
149 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11,
150 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6,
151 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0,
152 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2,
153 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3,
154 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11,
155 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1,
156 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10,
157 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7,
158 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5,
159
160 // and a second copy so we don't need an extra mask or static initializer
161 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7,
162 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8,
163 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8,
164 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5,
165 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1,
166 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4,
167 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11,
168 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6,
169 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0,
170 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2,
171 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3,
172 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11,
173 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1,
174 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10,
175 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7,
176 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5,
177 };
178
stb__perlin_lerp(float a,float b,float t)179 static float stb__perlin_lerp(float a, float b, float t)
180 {
181 return a + (b-a) * t;
182 }
183
stb__perlin_fastfloor(float a)184 static int stb__perlin_fastfloor(float a)
185 {
186 int ai = (int) a;
187 return (a < ai) ? ai-1 : ai;
188 }
189
190 // 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)191 static float stb__perlin_grad(int grad_idx, float x, float y, float z)
192 {
193 static float basis[12][4] =
194 {
195 { 1, 1, 0 },
196 { -1, 1, 0 },
197 { 1,-1, 0 },
198 { -1,-1, 0 },
199 { 1, 0, 1 },
200 { -1, 0, 1 },
201 { 1, 0,-1 },
202 { -1, 0,-1 },
203 { 0, 1, 1 },
204 { 0,-1, 1 },
205 { 0, 1,-1 },
206 { 0,-1,-1 },
207 };
208
209 float *grad = basis[grad_idx];
210 return grad[0]*x + grad[1]*y + grad[2]*z;
211 }
212
stb_perlin_noise3_internal(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap,unsigned char seed)213 float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)
214 {
215 float u,v,w;
216 float n000,n001,n010,n011,n100,n101,n110,n111;
217 float n00,n01,n10,n11;
218 float n0,n1;
219
220 unsigned int x_mask = (x_wrap-1) & 255;
221 unsigned int y_mask = (y_wrap-1) & 255;
222 unsigned int z_mask = (z_wrap-1) & 255;
223 int px = stb__perlin_fastfloor(x);
224 int py = stb__perlin_fastfloor(y);
225 int pz = stb__perlin_fastfloor(z);
226 int x0 = px & x_mask, x1 = (px+1) & x_mask;
227 int y0 = py & y_mask, y1 = (py+1) & y_mask;
228 int z0 = pz & z_mask, z1 = (pz+1) & z_mask;
229 int r0,r1, r00,r01,r10,r11;
230
231 #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)
232
233 x -= px; u = stb__perlin_ease(x);
234 y -= py; v = stb__perlin_ease(y);
235 z -= pz; w = stb__perlin_ease(z);
236
237 r0 = stb__perlin_randtab[x0+seed];
238 r1 = stb__perlin_randtab[x1+seed];
239
240 r00 = stb__perlin_randtab[r0+y0];
241 r01 = stb__perlin_randtab[r0+y1];
242 r10 = stb__perlin_randtab[r1+y0];
243 r11 = stb__perlin_randtab[r1+y1];
244
245 n000 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z0], x , y , z );
246 n001 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z1], x , y , z-1 );
247 n010 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z0], x , y-1, z );
248 n011 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z1], x , y-1, z-1 );
249 n100 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z0], x-1, y , z );
250 n101 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z1], x-1, y , z-1 );
251 n110 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z0], x-1, y-1, z );
252 n111 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z1], x-1, y-1, z-1 );
253
254 n00 = stb__perlin_lerp(n000,n001,w);
255 n01 = stb__perlin_lerp(n010,n011,w);
256 n10 = stb__perlin_lerp(n100,n101,w);
257 n11 = stb__perlin_lerp(n110,n111,w);
258
259 n0 = stb__perlin_lerp(n00,n01,v);
260 n1 = stb__perlin_lerp(n10,n11,v);
261
262 return stb__perlin_lerp(n0,n1,u);
263 }
264
stb_perlin_noise3(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap)265 float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)
266 {
267 return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap,0);
268 }
269
stb_perlin_noise3_seed(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap,int seed)270 float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)
271 {
272 return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap, (unsigned char) seed);
273 }
274
stb_perlin_ridge_noise3(float x,float y,float z,float lacunarity,float gain,float offset,int octaves)275 float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)
276 {
277 int i;
278 float frequency = 1.0f;
279 float prev = 1.0f;
280 float amplitude = 0.5f;
281 float sum = 0.0f;
282
283 for (i = 0; i < octaves; i++) {
284 float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i);
285 r = offset - (float) fabs(r);
286 r = r*r;
287 sum += r*amplitude*prev;
288 prev = r;
289 frequency *= lacunarity;
290 amplitude *= gain;
291 }
292 return sum;
293 }
294
stb_perlin_fbm_noise3(float x,float y,float z,float lacunarity,float gain,int octaves)295 float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
296 {
297 int i;
298 float frequency = 1.0f;
299 float amplitude = 1.0f;
300 float sum = 0.0f;
301
302 for (i = 0; i < octaves; i++) {
303 sum += stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
304 frequency *= lacunarity;
305 amplitude *= gain;
306 }
307 return sum;
308 }
309
stb_perlin_turbulence_noise3(float x,float y,float z,float lacunarity,float gain,int octaves)310 float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
311 {
312 int i;
313 float frequency = 1.0f;
314 float amplitude = 1.0f;
315 float sum = 0.0f;
316
317 for (i = 0; i < octaves; i++) {
318 float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
319 sum += (float) fabs(r);
320 frequency *= lacunarity;
321 amplitude *= gain;
322 }
323 return sum;
324 }
325
stb_perlin_noise3_wrap_nonpow2(float x,float y,float z,int x_wrap,int y_wrap,int z_wrap,unsigned char seed)326 float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)
327 {
328 float u,v,w;
329 float n000,n001,n010,n011,n100,n101,n110,n111;
330 float n00,n01,n10,n11;
331 float n0,n1;
332
333 int px = stb__perlin_fastfloor(x);
334 int py = stb__perlin_fastfloor(y);
335 int pz = stb__perlin_fastfloor(z);
336 int x_wrap2 = (x_wrap ? x_wrap : 256);
337 int y_wrap2 = (y_wrap ? y_wrap : 256);
338 int z_wrap2 = (z_wrap ? z_wrap : 256);
339 int x0 = px % x_wrap2, x1;
340 int y0 = py % y_wrap2, y1;
341 int z0 = pz % z_wrap2, z1;
342 int r0,r1, r00,r01,r10,r11;
343
344 if (x0 < 0) x0 += x_wrap2;
345 if (y0 < 0) y0 += y_wrap2;
346 if (z0 < 0) z0 += z_wrap2;
347 x1 = (x0+1) % x_wrap2;
348 y1 = (y0+1) % y_wrap2;
349 z1 = (z0+1) % z_wrap2;
350
351 #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)
352
353 x -= px; u = stb__perlin_ease(x);
354 y -= py; v = stb__perlin_ease(y);
355 z -= pz; w = stb__perlin_ease(z);
356
357 r0 = stb__perlin_randtab[x0];
358 r0 = stb__perlin_randtab[r0+seed];
359 r1 = stb__perlin_randtab[x1];
360 r1 = stb__perlin_randtab[r1+seed];
361
362 r00 = stb__perlin_randtab[r0+y0];
363 r01 = stb__perlin_randtab[r0+y1];
364 r10 = stb__perlin_randtab[r1+y0];
365 r11 = stb__perlin_randtab[r1+y1];
366
367 n000 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z0], x , y , z );
368 n001 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z1], x , y , z-1 );
369 n010 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z0], x , y-1, z );
370 n011 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z1], x , y-1, z-1 );
371 n100 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z0], x-1, y , z );
372 n101 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z1], x-1, y , z-1 );
373 n110 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z0], x-1, y-1, z );
374 n111 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z1], x-1, y-1, z-1 );
375
376 n00 = stb__perlin_lerp(n000,n001,w);
377 n01 = stb__perlin_lerp(n010,n011,w);
378 n10 = stb__perlin_lerp(n100,n101,w);
379 n11 = stb__perlin_lerp(n110,n111,w);
380
381 n0 = stb__perlin_lerp(n00,n01,v);
382 n1 = stb__perlin_lerp(n10,n11,v);
383
384 return stb__perlin_lerp(n0,n1,u);
385 }
386 #endif // STB_PERLIN_IMPLEMENTATION
387
388 /*
389 ------------------------------------------------------------------------------
390 This software is available under 2 licenses -- choose whichever you prefer.
391 ------------------------------------------------------------------------------
392 ALTERNATIVE A - MIT License
393 Copyright (c) 2017 Sean Barrett
394 Permission is hereby granted, free of charge, to any person obtaining a copy of
395 this software and associated documentation files (the "Software"), to deal in
396 the Software without restriction, including without limitation the rights to
397 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
398 of the Software, and to permit persons to whom the Software is furnished to do
399 so, subject to the following conditions:
400 The above copyright notice and this permission notice shall be included in all
401 copies or substantial portions of the Software.
402 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
403 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
404 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
405 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
406 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
407 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
408 SOFTWARE.
409 ------------------------------------------------------------------------------
410 ALTERNATIVE B - Public Domain (www.unlicense.org)
411 This is free and unencumbered software released into the public domain.
412 Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
413 software, either in source code form or as a compiled binary, for any purpose,
414 commercial or non-commercial, and by any means.
415 In jurisdictions that recognize copyright laws, the author or authors of this
416 software dedicate any and all copyright interest in the software to the public
417 domain. We make this dedication for the benefit of the public at large and to
418 the detriment of our heirs and successors. We intend this dedication to be an
419 overt act of relinquishment in perpetuity of all present and future rights to
420 this software under copyright law.
421 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
422 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
423 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
424 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
425 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
426 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
427 ------------------------------------------------------------------------------
428 */
429