forked from WardBenjamin/SimplexNoise
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Noise.cs
412 lines (362 loc) · 17.7 KB
/
Noise.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
// Simplex Noise for C#
// Copyright © Benjamin Ward 2019
// See LICENSE
// Simplex Noise implementation offering 1D, 2D, and 3D forms w/ values in the range of 0 to 255.
// Based on work by Heikki Törmälä (2012) and Stefan Gustavson (2006).
using System;
namespace SimplexNoise
{
/// <summary>
/// Implementation of the Perlin simplex noise, an improved Perlin noise algorithm.
/// Based loosely on SimplexNoise1234 by Stefan Gustavson: http://staffwww.itn.liu.se/~stegu/aqsis/aqsis-newnoise/
/// </summary>
public static class Noise
{
/// <summary>
/// Creates 1D Simplex noise
/// </summary>
/// <param name="width">The number of points to generate</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>An array containing 1D Simplex noise</returns>
public static float[] Calc1D(int width, float scale)
{
var values = new float[width];
for (var i = 0; i < width; i++)
values[i] = Generate(i * scale) * 128 + 128;
return values;
}
/// <summary>
/// Creates 2D Simplex noise
/// </summary>
/// <param name="width">The number of points to generate in the 1st dimension</param>
/// <param name="height">The number of points to generate in the 2nd dimension</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>An array containing 2D Simplex noise</returns>
public static float[,] Calc2D(int width, int height, float scale)
{
var values = new float[width, height];
for (var i = 0; i < width; i++)
for (var j = 0; j < height; j++)
values[i, j] = Generate(i * scale, j * scale) * 128 + 128;
return values;
}
/// <summary>
/// Creates 3D Simplex noise
/// </summary>
/// <param name="width">The number of points to generate in the 1st dimension</param>
/// <param name="height">The number of points to generate in the 2nd dimension</param>
/// <param name="length">The number of points to generate in the 3nd dimension</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>An array containing 3D Simplex noise</returns>
public static float[, ,] Calc3D(int width, int height, int length, float scale)
{
var values = new float[width, height, length];
for (var i = 0; i < width; i++)
for (var j = 0; j < height; j++)
for (var k = 0; k < length; k++)
values[i, j, k] = Generate(i * scale, j * scale, k * scale) * 128 + 128;
return values;
}
/// <summary>
/// Gets the value of an index of 1D simplex noise
/// </summary>
/// <param name="x">Index</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>The value of an index of 1D simplex noise</returns>
public static float CalcPixel1D(int x, float scale)
{
return Generate(x * scale) * 128 + 128;
}
/// <summary>
/// Gets the value of an index of 2D simplex noise
/// </summary>
/// <param name="x">1st dimension index</param>
/// <param name="y">2st dimension index</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>The value of an index of 2D simplex noise</returns>
public static float CalcPixel2D(int x, int y, float scale)
{
return Generate(x * scale, y * scale) * 128 + 128;
}
/// <summary>
/// Gets the value of an index of 3D simplex noise
/// </summary>
/// <param name="x">1st dimension index</param>
/// <param name="y">2nd dimension index</param>
/// <param name="z">3rd dimension index</param>
/// <param name="scale">The scale of the noise. The greater the scale, the denser the noise gets</param>
/// <returns>The value of an index of 3D simplex noise</returns>
public static float CalcPixel3D(int x, int y, int z, float scale)
{
return Generate(x * scale, y * scale, z * scale) * 128 + 128;
}
static Noise()
{
_perm = new byte[PermOriginal.Length];
PermOriginal.CopyTo(_perm, 0);
}
/// <summary>
/// Arbitrary integer seed used to generate lookup table used internally
/// </summary>
public static int Seed
{
get => _seed;
set
{
if (value == 0)
{
_perm = new byte[PermOriginal.Length];
PermOriginal.CopyTo(_perm, 0);
}
else
{
_perm = new byte[512];
var random = new Random(value);
random.NextBytes(_perm);
}
_seed = value;
}
}
private static int _seed;
/// <summary>
/// 1D simplex noise
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
private static float Generate(float x)
{
var i0 = FastFloor(x);
var i1 = i0 + 1;
var x0 = x - i0;
var x1 = x0 - 1.0f;
var t0 = 1.0f - x0 * x0;
t0 *= t0;
var n0 = t0 * t0 * Grad(_perm[i0 & 0xff], x0);
var t1 = 1.0f - x1 * x1;
t1 *= t1;
var n1 = t1 * t1 * Grad(_perm[i1 & 0xff], x1);
// The maximum value of this noise is 8*(3/4)^4 = 2.53125
// A factor of 0.395 scales to fit exactly within [-1,1]
return 0.395f * (n0 + n1);
}
/// <summary>
/// 2D simplex noise
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
private static float Generate(float x, float y)
{
const float F2 = 0.366025403f; // F2 = 0.5*(sqrt(3.0)-1.0)
const float G2 = 0.211324865f; // G2 = (3.0-Math.sqrt(3.0))/6.0
float n0, n1, n2; // Noise contributions from the three corners
// Skew the input space to determine which simplex cell we're in
var s = (x + y) * F2; // Hairy factor for 2D
var xs = x + s;
var ys = y + s;
var i = FastFloor(xs);
var j = FastFloor(ys);
var t = (i + j) * G2;
var X0 = i - t; // Unskew the cell origin back to (x,y) space
var Y0 = j - t;
var x0 = x - X0; // The x,y distances from the cell origin
var y0 = y - Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if (x0 > y0) { i1 = 1; j1 = 0; } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
else { i1 = 0; j1 = 1; } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
var y1 = y0 - j1 + G2;
var x2 = x0 - 1.0f + 2.0f * G2; // Offsets for last corner in (x,y) unskewed coords
var y2 = y0 - 1.0f + 2.0f * G2;
// Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
var ii = Mod(i, 256);
var jj = Mod(j, 256);
// Calculate the contribution from the three corners
var t0 = 0.5f - x0 * x0 - y0 * y0;
if (t0 < 0.0f) n0 = 0.0f;
else
{
t0 *= t0;
n0 = t0 * t0 * Grad(_perm[ii + _perm[jj]], x0, y0);
}
var t1 = 0.5f - x1 * x1 - y1 * y1;
if (t1 < 0.0f) n1 = 0.0f;
else
{
t1 *= t1;
n1 = t1 * t1 * Grad(_perm[ii + i1 + _perm[jj + j1]], x1, y1);
}
var t2 = 0.5f - x2 * x2 - y2 * y2;
if (t2 < 0.0f) n2 = 0.0f;
else
{
t2 *= t2;
n2 = t2 * t2 * Grad(_perm[ii + 1 + _perm[jj + 1]], x2, y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 40.0f * (n0 + n1 + n2); // TODO: The scale factor is preliminary!
}
private static float Generate(float x, float y, float z)
{
// Simple skewing factors for the 3D case
const float F3 = 0.333333333f;
const float G3 = 0.166666667f;
float n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
var s = (x + y + z) * F3; // Very nice and simple skew factor for 3D
var xs = x + s;
var ys = y + s;
var zs = z + s;
var i = FastFloor(xs);
var j = FastFloor(ys);
var k = FastFloor(zs);
var t = (i + j + k) * G3;
var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
var Y0 = j - t;
var Z0 = k - t;
var x0 = x - X0; // The x,y,z distances from the cell origin
var y0 = y - Y0;
var z0 = z - Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
/* This code would benefit from a backport from the GLSL version! */
if (x0 >= y0)
{
if (y0 >= z0)
{ i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // X Y Z order
else if (x0 >= z0) { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; } // X Z Y order
else { i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; } // Z X Y order
}
else
{ // x0<y0
if (y0 < z0) { i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; } // Z Y X order
else if (x0 < z0) { i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; } // Y Z X order
else { i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
var y1 = y0 - j1 + G3;
var z1 = z0 - k1 + G3;
var x2 = x0 - i2 + 2.0f * G3; // Offsets for third corner in (x,y,z) coords
var y2 = y0 - j2 + 2.0f * G3;
var z2 = z0 - k2 + 2.0f * G3;
var x3 = x0 - 1.0f + 3.0f * G3; // Offsets for last corner in (x,y,z) coords
var y3 = y0 - 1.0f + 3.0f * G3;
var z3 = z0 - 1.0f + 3.0f * G3;
// Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
var ii = Mod(i, 256);
var jj = Mod(j, 256);
var kk = Mod(k, 256);
// Calculate the contribution from the four corners
var t0 = 0.6f - x0 * x0 - y0 * y0 - z0 * z0;
if (t0 < 0.0f) n0 = 0.0f;
else
{
t0 *= t0;
n0 = t0 * t0 * Grad(_perm[ii + _perm[jj + _perm[kk]]], x0, y0, z0);
}
var t1 = 0.6f - x1 * x1 - y1 * y1 - z1 * z1;
if (t1 < 0.0f) n1 = 0.0f;
else
{
t1 *= t1;
n1 = t1 * t1 * Grad(_perm[ii + i1 + _perm[jj + j1 + _perm[kk + k1]]], x1, y1, z1);
}
var t2 = 0.6f - x2 * x2 - y2 * y2 - z2 * z2;
if (t2 < 0.0f) n2 = 0.0f;
else
{
t2 *= t2;
n2 = t2 * t2 * Grad(_perm[ii + i2 + _perm[jj + j2 + _perm[kk + k2]]], x2, y2, z2);
}
var t3 = 0.6f - x3 * x3 - y3 * y3 - z3 * z3;
if (t3 < 0.0f) n3 = 0.0f;
else
{
t3 *= t3;
n3 = t3 * t3 * Grad(_perm[ii + 1 + _perm[jj + 1 + _perm[kk + 1]]], x3, y3, z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0f * (n0 + n1 + n2 + n3); // TODO: The scale factor is preliminary!
}
private static byte[] _perm;
private static readonly byte[] PermOriginal = {
151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
};
private static int FastFloor(float x)
{
return (x > 0) ? ((int)x) : (((int)x) - 1);
}
private static int Mod(int x, int m)
{
var a = x % m;
return a < 0 ? a + m : a;
}
private static float Grad(int hash, float x)
{
var h = hash & 15;
var grad = 1.0f + (h & 7); // Gradient value 1.0, 2.0, ..., 8.0
if ((h & 8) != 0) grad = -grad; // Set a random sign for the gradient
return (grad * x); // Multiply the gradient with the distance
}
private static float Grad(int hash, float x, float y)
{
var h = hash & 7; // Convert low 3 bits of hash code
var u = h < 4 ? x : y; // into 8 simple gradient directions,
var v = h < 4 ? y : x; // and compute the dot product with (x,y).
return ((h & 1) != 0 ? -u : u) + ((h & 2) != 0 ? -2.0f * v : 2.0f * v);
}
private static float Grad(int hash, float x, float y, float z)
{
var h = hash & 15; // Convert low 4 bits of hash code into 12 simple
var u = h < 8 ? x : y; // gradient directions, and compute dot product.
var v = h < 4 ? y : h == 12 || h == 14 ? x : z; // Fix repeats at h = 12 to 15
return ((h & 1) != 0 ? -u : u) + ((h & 2) != 0 ? -v : v);
}
private static float Grad(int hash, float x, float y, float z, float t)
{
var h = hash & 31; // Convert low 5 bits of hash code into 32 simple
var u = h < 24 ? x : y; // gradient directions, and compute dot product.
var v = h < 16 ? y : z;
var w = h < 8 ? z : t;
return ((h & 1) != 0 ? -u : u) + ((h & 2) != 0 ? -v : v) + ((h & 4) != 0 ? -w : w);
}
}
}