stb/stb_perlin.h

   1 // stb_perlin.h - v0.2 - perlin noise
   2 // public domain single-file C implementation by Sean Barrett
   3 //
   4 // LICENSE
   5 //
   6 //   This software is dual-licensed to the public domain and under the following
   7 //   license: you are granted a perpetual, irrevocable license to copy, modify,
   8 //   publish, and distribute this file as you see fit.
   9 //
  10 //
  11 // to create the implementation,
  12 //     #define STB_PERLIN_IMPLEMENTATION
  13 // in *one* C/CPP file that includes this file.
  14
  15
  16 // Documentation:
  17 //
  18 // float  stb_perlin_noise3( float x,
  19 //                           float y,
  20 //                           float z,
  21 //                           int   x_wrap=0,
  22 //                           int   y_wrap=0,
  23 //                           int   z_wrap=0)
  24 //
  25 // This function computes a random value at the coordinate (x,y,z).
  26 // Adjacent random values are continuous but the noise fluctuates
  27 // its randomness with period 1, i.e. takes on wholly unrelated values
  28 // at integer points. Specifically, this implements Ken Perlin's
  29 // revised noise function from 2002.
  30 //
  31 // The "wrap" parameters can be used to create wraparound noise that
  32 // wraps at powers of two. The numbers MUST be powers of two. Specify
  33 // 0 to mean "don't care". (The noise always wraps every 256 due
  34 // details of the implementation, even if you ask for larger or no
  35 // wrapping.)
  36
  37
  38 #ifdef __cplusplus
  39 extern "C" float stb_perlin_noise3(float x, float y, float z, int x_wrap=0, int y_wrap=0, int z_wrap=0);
  40 #else
  41 extern float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap);
  42 #endif
  43
  44 #ifdef STB_PERLIN_IMPLEMENTATION
  45
  46 #include <math.h> // floor()
  47
  48 // not same permutation table as Perlin's reference to avoid copyright issues;
  49 // Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/
  50 // @OPTIMIZE: should this be unsigned char instead of int for cache?
  51 static int stb__perlin_randtab[512] =
  52 {
  53    23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
  54    152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
  55    175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
  56    8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
  57    225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
  58    94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
  59    165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
  60    65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
  61    26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
  62    250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
  63    132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
  64    91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
  65    38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
  66    131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
  67    27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
  68    61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
  69
  70    // and a second copy so we don't need an extra mask or static initializer
  71    23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123,
  72    152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72,
  73    175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240,
  74    8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57,
  75    225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233,
  76    94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172,
  77    165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243,
  78    65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122,
  79    26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76,
  80    250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246,
  81    132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3,
  82    91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231,
  83    38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221,
  84    131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62,
  85    27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135,
  86    61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,
  87 };
  88
  89 static float stb__perlin_lerp(float a, float b, float t)
  90 {
  91    return a + (b-a) * t;
  92 }
  93
  94 // different grad function from Perlin's, but easy to modify to match reference
  95 static float stb__perlin_grad(int hash, float x, float y, float z)
  96 {
  97    static float basis[12][4] =
  98    {
  99       {  1, 1, 0 },
 100       { -1, 1, 0 },
 101       {  1,-1, 0 },
 102       { -1,-1, 0 },
 103       {  1, 0, 1 },
 104       { -1, 0, 1 },
 105       {  1, 0,-1 },
 106       { -1, 0,-1 },
 107       {  0, 1, 1 },
 108       {  0,-1, 1 },
 109       {  0, 1,-1 },
 110       {  0,-1,-1 },
 111    };
 112
 113    // perlin's gradient has 12 cases so some get used 1/16th of the time
 114    // and some 2/16ths. We reduce bias by changing those fractions
 115    // to 5/16ths and 6/16ths, and the same 4 cases get the extra weight.
 116    static unsigned char indices[64] =
 117    {
 118       0,1,2,3,4,5,6,7,8,9,10,11,
 119       0,9,1,11,
 120       0,1,2,3,4,5,6,7,8,9,10,11,
 121       0,1,2,3,4,5,6,7,8,9,10,11,
 122       0,1,2,3,4,5,6,7,8,9,10,11,
 123       0,1,2,3,4,5,6,7,8,9,10,11,
 124    };
 125
 126    // if you use reference permutation table, change 63 below to 15 to match reference
 127    float *grad = basis[indices[hash & 63]];
 128    return grad[0]*x + grad[1]*y + grad[2]*z;
 129 }
 130
 131 float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)
 132 {
 133    float u,v,w;
 134    float n000,n001,n010,n011,n100,n101,n110,n111;
 135    float n00,n01,n10,n11;
 136    float n0,n1;
 137
 138    unsigned int x_mask = (x_wrap-1) & 255;
 139    unsigned int y_mask = (y_wrap-1) & 255;
 140    unsigned int z_mask = (z_wrap-1) & 255;
 141    int px = (int) floor(x);
 142    int py = (int) floor(y);
 143    int pz = (int) floor(z);
 144    int x0 = px & x_mask, x1 = (px+1) & x_mask;
 145    int y0 = py & y_mask, y1 = (py+1) & y_mask;
 146    int z0 = pz & z_mask, z1 = (pz+1) & z_mask;
 147    int r0,r1, r00,r01,r10,r11;
 148
 149    #define stb__perlin_ease(a)   (((a*6-15)*a + 10) * a * a * a)
 150
 151    x -= px; u = stb__perlin_ease(x);
 152    y -= py; v = stb__perlin_ease(y);
 153    z -= pz; w = stb__perlin_ease(z);
 154
 155    r0 = stb__perlin_randtab[x0];
 156    r1 = stb__perlin_randtab[x1];
 157
 158    r00 = stb__perlin_randtab[r0+y0];
 159    r01 = stb__perlin_randtab[r0+y1];
 160    r10 = stb__perlin_randtab[r1+y0];
 161    r11 = stb__perlin_randtab[r1+y1];
 162
 163    n000 = stb__perlin_grad(stb__perlin_randtab[r00+z0], x  , y  , z   );
 164    n001 = stb__perlin_grad(stb__perlin_randtab[r00+z1], x  , y  , z-1 );
 165    n010 = stb__perlin_grad(stb__perlin_randtab[r01+z0], x  , y-1, z   );
 166    n011 = stb__perlin_grad(stb__perlin_randtab[r01+z1], x  , y-1, z-1 );
 167    n100 = stb__perlin_grad(stb__perlin_randtab[r10+z0], x-1, y  , z   );
 168    n101 = stb__perlin_grad(stb__perlin_randtab[r10+z1], x-1, y  , z-1 );
 169    n110 = stb__perlin_grad(stb__perlin_randtab[r11+z0], x-1, y-1, z   );
 170    n111 = stb__perlin_grad(stb__perlin_randtab[r11+z1], x-1, y-1, z-1 );
 171
 172    n00 = stb__perlin_lerp(n000,n001,w);
 173    n01 = stb__perlin_lerp(n010,n011,w);
 174    n10 = stb__perlin_lerp(n100,n101,w);
 175    n11 = stb__perlin_lerp(n110,n111,w);
 176
 177    n0 = stb__perlin_lerp(n00,n01,v);
 178    n1 = stb__perlin_lerp(n10,n11,v);
 179
 180    return stb__perlin_lerp(n0,n1,u);
 181 }
 182 #endif  // STB_PERLIN_IMPLEMENTATION