1 // stb_perlin.h - v0.2 - perlin noise
2 // public domain single-file C implementation by Sean Barrett
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.
11 // to create the implementation,
12 // #define STB_PERLIN_IMPLEMENTATION
13 // in *one* C/CPP file that includes this file.
18 // float stb_perlin_noise3( float x,
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.
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
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);
41 extern float stb_perlin_noise3(float x
, float y
, float z
, int x_wrap
, int y_wrap
, int z_wrap
);
44 #ifdef STB_PERLIN_IMPLEMENTATION
46 #include <math.h> // floor()
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] =
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,
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,
89 static float stb__perlin_lerp(float a
, float b
, float t
)
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
)
97 static float basis
[12][4] =
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] =
118 0,1,2,3,4,5,6,7,8,9,10,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,
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
;
131 float stb_perlin_noise3(float x
, float y
, float z
, int x_wrap
, int y_wrap
, int z_wrap
)
134 float n000
,n001
,n010
,n011
,n100
,n101
,n110
,n111
;
135 float n00
,n01
,n10
,n11
;
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
;
149 #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)
151 x
-= px
; u
= stb__perlin_ease(x
);
152 y
-= py
; v
= stb__perlin_ease(y
);
153 z
-= pz
; w
= stb__perlin_ease(z
);
155 r0
= stb__perlin_randtab
[x0
];
156 r1
= stb__perlin_randtab
[x1
];
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
];
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 );
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
);
177 n0
= stb__perlin_lerp(n00
,n01
,v
);
178 n1
= stb__perlin_lerp(n10
,n11
,v
);
180 return stb__perlin_lerp(n0
,n1
,u
);
182 #endif // STB_PERLIN_IMPLEMENTATION