stb_perlin.h (17918B)
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 179 static float stb__perlin_lerp(float a, float b, float t) 180 { 181 return a + (b-a) * t; 182 } 183 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 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 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 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 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 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 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 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 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 */