@woosh/meep-engine
Version:
Pure JavaScript game engine. Fully featured and production ready.
951 lines (782 loc) • 33.5 kB
JavaScript
const v2_array = [];
const v3_array = [];
const v4_array = [];
/* Static data ---------------------- */
/*
* Permutation table. This is just a random jumble of all numbers 0-255,
* repeated twice to avoid wrapping the index at 255 for each lookup.
* TODO we can initialize this per instance of noise
*/
const perm = new Uint8Array([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
]);
/**
* Gradient tables. These could be programmed the Ken Perlin way with
* some clever bit-twiddling, but this is more clear, and not really slower.
*
* PORT NOTES: static float grad2lut[8][2]
*
* @readonly
* @type {Int8Array}
*/
const grad2lut = new Int8Array([
-1.0, -1.0,
1.0, 0.0,
-1.0, 0.0,
1.0, 1.0,
-1.0, 1.0,
0.0, -1.0,
0.0, 1.0,
1.0, -1.0
]);
/**
* Gradient directions for 3D.
* These vectors are based on the midpoints of the 12 edges of a cube.
* A larger array of random unit length vectors would also do the job,
* but these 12 (including 4 repeats to make the array length a power
* of two) work better. They are not random, they are carefully chosen
* to represent a small, isotropic set of directions.
*
* PORT NOTES: static float grad3lut[16][3]
*
* @readonly
* @type {Int8Array}
*/
const grad3lut = new Int8Array([
1.0, 0.0, 1.0, 0.0, 1.0, 1.0, // 12 cube edges
-1.0, 0.0, 1.0, 0.0, -1.0, 1.0,
1.0, 0.0, -1.0, 0.0, 1.0, -1.0,
-1.0, 0.0, -1.0, 0.0, -1.0, -1.0,
1.0, -1.0, 0.0, 1.0, 1.0, 0.0,
-1.0, 1.0, 0.0, -1.0, -1.0, 0.0,
1.0, 0.0, 1.0, -1.0, 0.0, 1.0, // 4 repeats to make 16
0.0, 1.0, -1.0, 0.0, -1.0, -1.0
]);
/**
* PORT NOTES: static float grad3lut[32][4]
*
* @readonly
* @type {Int8Array}
*/
const grad4lut = new Int8Array([
0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 0.0, 1.0, -1.0, 1.0, 0.0, 1.0, -1.0, -1.0, // 32 tesseract edges
0.0, -1.0, 1.0, 1.0, 0.0, -1.0, 1.0, -1.0, 0.0, -1.0, -1.0, 1.0, 0.0, -1.0, -1.0, -1.0,
1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, -1.0, 1.0, 0.0, -1.0, 1.0, 1.0, 0.0, -1.0, -1.0,
-1.0, 0.0, 1.0, 1.0, -1.0, 0.0, 1.0, -1.0, -1.0, 0.0, -1.0, 1.0, -1.0, 0.0, -1.0, -1.0,
1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, -1.0, 1.0, -1.0, 0.0, 1.0, 1.0, -1.0, 0.0, -1.0,
-1.0, 1.0, 0.0, 1.0, -1.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0, 1.0, -1.0, -1.0, 0.0, -1.0,
1.0, 1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 0.0, 1.0, -1.0, 1.0, 0.0, 1.0, -1.0, -1.0, 0.0,
-1.0, 1.0, 1.0, 0.0, -1.0, 1.0, -1.0, 0.0, -1.0, -1.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0
]);
/**
* A lookup table to traverse the simplex around a given point in 4D.
* Details can be found where this table is used, in the 4D noise method.
* TODO: This should not be required, backport it from Bill's GLSL code!
*
* PORT NOTES: static unsigned char simplex[64][4]
* @readonly
* @type {Uint8Array}
*/
const simplex = new Uint8Array([
0, 1, 2, 3, 0, 1, 3, 2, 0, 0, 0, 0, 0, 2, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 0,
0, 2, 1, 3, 0, 0, 0, 0, 0, 3, 1, 2, 0, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 2, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 2, 0, 3, 0, 0, 0, 0, 1, 3, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 1, 2, 3, 1, 0,
1, 0, 2, 3, 1, 0, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 1, 0, 0, 0, 0, 2, 1, 3, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 2, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 2, 0,
2, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 2, 0, 0, 0, 0, 3, 2, 0, 1, 3, 2, 1, 0
]);
/* --------------------------------------------------------------------- */
/*
* Helper functions to compute gradients in 1D to 4D
* and gradients-dot-residualvectors in 2D to 4D.
*/
/**
*
* @param {number} hash
* @returns {number}
*/
function grad1(hash) {
const h = hash & 15;
let gx = 1.0 + (h & 7); // Gradient value is one of 1.0, 2.0, ..., 8.0
if (h & 8) gx = -gx; // Make half of the gradients negative
return gx;
}
/**
*
* @param {number[]} result
* @param {number} hash
*/
function grad2(result, hash) {
const h = hash & 7;
const h2 = h * 2;
result[0] = grad2lut[h2];
result[1] = grad2lut[h2 + 1];
}
/**
*
* @param {number[]} result
* @param {number} hash
*/
function grad3(result, hash) {
const h = hash & 15;
const h3 = h * 3;
result[0] = grad3lut[h3];
result[1] = grad3lut[h3 + 1];
result[2] = grad3lut[h3 + 2];
}
/**
*
* @param {number[]} result
* @param {number} hash
*/
function grad4(result, hash) {
const h = hash & 31;
const h4 = h * 4;
result[0] = grad4lut[h4];
result[1] = grad4lut[h4 + 1];
result[2] = grad4lut[h4 + 2];
result[3] = grad4lut[h4 + 3];
}
/**
* 1D simplex noise with derivative.
* If the last argument is not null, the analytic derivative
* is also calculated.
* @param {number} x
* @param {number[]} derivatives
* @returns {number}
*/
export function sdnoise1(derivatives, x) {
const i0 = x | 0;
const i1 = i0 + 1;
const x0 = x - i0;
const x1 = x0 - 1.0;
let gx0, gx1;
let n0, n1;
let t1, t20, t40, t21, t41, x21;
const x20 = x0 * x0;
const t0 = 1.0 - x20;
// if(t0 < 0.0f) t0 = 0.0f; // Never happens for 1D: x0<=1 always
t20 = t0 * t0;
t40 = t20 * t20;
gx0 = grad1(perm[i0 & 0xff]);
n0 = t40 * gx0 * x0;
x21 = x1 * x1;
t1 = 1.0 - x21;
// if(t1 < 0.0f) t1 = 0.0f; // Never happens for 1D: |x1|<=1 always
t21 = t1 * t1;
t41 = t21 * t21;
gx1 = grad1(perm[i1 & 0xff]);
n1 = t41 * gx1 * x1;
/* Compute derivative, if requested by supplying non-null pointer
* for the last argument
* Compute derivative according to:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * (gx0 * x0) + t40 * gx0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * (gx1 * x1) + t41 * gx1;
*/
let dnoise_dx = t20 * t0 * gx0 * x20;
dnoise_dx += t21 * t1 * gx1 * x21;
dnoise_dx *= -8.0;
dnoise_dx += t40 * gx0 + t41 * gx1;
dnoise_dx *= 0.25; /* Scale derivative to match the noise scaling */
derivatives[0] = dnoise_dx;
// The maximum value of this noise is 8*(3/4)^4 = 2.53125
// A factor of 0.395 would scale to fit exactly within [-1,1], but
// to better match classic Perlin noise, we scale it down some more.
return 0.25 * (n0 + n1);
}
/* Skewing factors for 2D simplex grid:
* F2 = 0.5*(sqrt(3.0)-1.0)
* G2 = (3.0-Math.sqrt(3.0))/6.0
*/
const F2 = 0.3660254037844386;
const G2 = 0.21132486540518713;
/** 2D simplex noise with derivatives.
* If the last two arguments are not null, the analytic derivative
* (the 2D gradient of the scalar noise field) is also calculated.
*
* @param {number} x
* @param {number} y
* @param {number[]} derivatives
* @returns {number}
*/
export function sdnoise2(derivatives, x, y) {
let n0, n1, n2; /* Noise contributions from the three simplex corners */
let gx0, gy0, gx1, gy1, gx2, gy2; /* Gradients at simplex corners */
let t0, t1, t2, x1, x2, y1, y2;
let t20, t40, t21, t41, t22, t42;
let temp0, temp1, temp2, noise;
/* Skew the input space to determine which simplex cell we're in */
const s = (x + y) * F2; /* Hairy factor for 2D */
const xs = x + s;
const ys = y + s;
let ii, i = xs | 0;
let jj, j = ys | 0;
const t = (i + j) * G2;
const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
const Y0 = j - t;
const x0 = x - X0; /* The x,y distances from the cell origin */
const y0 = y - Y0;
/* For the 2D case, the simplex shape is an equilateral triangle.
* Determine which simplex we are in. */
let 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 */
x1 = x0 - i1 + G2; /* Offsets for middle corner in (x,y) unskewed coords */
y1 = y0 - j1 + G2;
x2 = x0 - 1.0 + 2.0 * G2; /* Offsets for last corner in (x,y) unskewed coords */
y2 = y0 - 1.0 + 2.0 * G2;
/* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
ii = i % 256;
jj = j % 256;
/* Calculate the contribution from the three corners */
t0 = 0.5 - x0 * x0 - y0 * y0;
if (t0 < 0.0) {
t40 = t20 = t0 = n0 = gx0 = gy0 = 0.0; /* No influence */
} else {
grad2(v2_array, perm[ii + perm[jj]]);
gx0 = v2_array[0];
gy0 = v2_array[1];
t20 = t0 * t0;
t40 = t20 * t20;
n0 = t40 * (gx0 * x0 + gy0 * y0);
}
t1 = 0.5 - x1 * x1 - y1 * y1;
if (t1 < 0.0) {
t21 = t41 = t1 = n1 = gx1 = gy1 = 0.0; /* No influence */
} else {
grad2(v2_array, perm[ii + i1 + perm[jj + j1]]);
gx1 = v2_array[0];
gy1 = v2_array[1];
t21 = t1 * t1;
t41 = t21 * t21;
n1 = t41 * (gx1 * x1 + gy1 * y1);
}
t2 = 0.5 - x2 * x2 - y2 * y2;
if (t2 < 0.0) {
t42 = t22 = t2 = n2 = gx2 = gy2 = 0.0; /* No influence */
} else {
grad2(v2_array, perm[ii + 1 + perm[jj + 1]]);
gx2 = v2_array[0];
gy2 = v2_array[1];
t22 = t2 * t2;
t42 = t22 * t22;
n2 = t42 * (gx2 * x2 + gy2 * y2);
}
/* Add contributions from each corner to get the final noise value.
* The result is scaled to return values in the interval [-1,1]. */
noise = 40.0 * (n0 + n1 + n2);
/* Compute derivative, if requested by supplying non-null pointers
* for the last two arguments */
/* A straight, unoptimised calculation would be like:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * ( gx0 * x0 + gy0 * y0 ) + t40 * gx0;
* *dnoise_dy = -8.0f * t20 * t0 * y0 * ( gx0 * x0 + gy0 * y0 ) + t40 * gy0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * ( gx1 * x1 + gy1 * y1 ) + t41 * gx1;
* *dnoise_dy += -8.0f * t21 * t1 * y1 * ( gx1 * x1 + gy1 * y1 ) + t41 * gy1;
* *dnoise_dx += -8.0f * t22 * t2 * x2 * ( gx2 * x2 + gy2 * y2 ) + t42 * gx2;
* *dnoise_dy += -8.0f * t22 * t2 * y2 * ( gx2 * x2 + gy2 * y2 ) + t42 * gy2;
*/
temp0 = t20 * t0 * (gx0 * x0 + gy0 * y0);
let dnoise_dx = temp0 * x0;
let dnoise_dy = temp0 * y0;
temp1 = t21 * t1 * (gx1 * x1 + gy1 * y1);
dnoise_dx += temp1 * x1;
dnoise_dy += temp1 * y1;
temp2 = t22 * t2 * (gx2 * x2 + gy2 * y2);
dnoise_dx += temp2 * x2;
dnoise_dy += temp2 * y2;
dnoise_dx *= -8.0;
dnoise_dy *= -8.0;
dnoise_dx += t40 * gx0 + t41 * gx1 + t42 * gx2;
dnoise_dy += t40 * gy0 + t41 * gy1 + t42 * gy2;
dnoise_dx *= 40.0; /* Scale derivative to match the noise scaling */
dnoise_dy *= 40.0;
derivatives[0] = dnoise_dx;
derivatives[1] = dnoise_dy;
return noise;
}
/* Skewing factors for 3D simplex grid:
* F3 = 1/3
* G3 = 1/6 */
const F3 = 0.3333333333333333;
const G3 = 0.16666666666666666;
/** 3D simplex noise with derivatives.
* If the last tthree arguments are not null, the analytic derivative
* (the 3D gradient of the scalar noise field) is also calculated.
*
* @param {number} x
* @param {number} y
* @param {number} z
* @param {number[]} derivatives
* @returns {number}
*/
export function sdnoise3(derivatives, x, y, z) {
let n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
let gx0, gy0, gz0, gx1, gy1, gz1; /* Gradients at simplex corners */
let gx2, gy2, gz2, gx3, gy3, gz3;
let t0, t1, t2, t3, t20, t40, t21, t41, t22, t42, t23, t43;
let i1, j1, k1; /* Offsets for second corner of simplex in (i,j,k) coords */
let i2, j2, k2; /* Offsets for third corner of simplex in (i,j,k) coords */
/* Skew the input space to determine which simplex cell we're in */
const s = (x + y + z) * F3; /* Very nice and simple skew factor for 3D */
const xs = x + s;
const ys = y + s;
const zs = z + s;
const i = xs | 0;
const j = ys | 0;
const k = zs | 0;
const t = (i + j + k) * G3;
const X0 = i - t; /* Unskew the cell origin back to (x,y,z) space */
const Y0 = j - t;
const Z0 = k - t;
const x0 = x - X0; /* The x,y,z distances from the cell origin */
const y0 = y - Y0;
const z0 = z - Z0;
/* For the 3D case, the simplex shape is a slightly irregular tetrahedron.
* Determine which simplex we are in. */
/* TODO: 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. */
const x1 = x0 - i1 + G3; /* Offsets for second corner in (x,y,z) coords */
const y1 = y0 - j1 + G3;
const z1 = z0 - k1 + G3;
const G6 = G3 + G3;
const x2 = x0 - i2 + G6; /* Offsets for third corner in (x,y,z) coords */
const y2 = y0 - j2 + G6;
const z2 = z0 - k2 + G6;
const G9 = G6 + G3;
const x3 = x0 - 1.0 + G9; /* Offsets for last corner in (x,y,z) coords */
const y3 = y0 - 1.0 + G9;
const z3 = z0 - 1.0 + G9;
/* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
const ii = i & 255;
const jj = j & 255;
const kk = k & 255;
/* Calculate the contribution from the four corners */
t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
if (t0 < 0.0) {
n0 = t0 = t20 = t40 = gx0 = gy0 = gz0 = 0.0;
} else {
grad3(v3_array, perm[ii + perm[jj + perm[kk]]]);
gx0 = v3_array[0];
gy0 = v3_array[1];
gz0 = v3_array[2];
t20 = t0 * t0;
t40 = t20 * t20;
n0 = t40 * (gx0 * x0 + gy0 * y0 + gz0 * z0);
}
t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
if (t1 < 0.0) {
n1 = t1 = t21 = t41 = gx1 = gy1 = gz1 = 0.0;
} else {
grad3(v3_array, perm[ii + i1 + perm[jj + j1 + perm[kk + k1]]]);
gx1 = v3_array[0];
gy1 = v3_array[1];
gz1 = v3_array[2];
t21 = t1 * t1;
t41 = t21 * t21;
n1 = t41 * (gx1 * x1 + gy1 * y1 + gz1 * z1);
}
t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
if (t2 < 0.0) {
n2 = t2 = t22 = t42 = gx2 = gy2 = gz2 = 0.0;
} else {
grad3(v3_array, perm[ii + i2 + perm[jj + j2 + perm[kk + k2]]]);
gx2 = v3_array[0];
gy2 = v3_array[1];
gz2 = v3_array[2];
t22 = t2 * t2;
t42 = t22 * t22;
n2 = t42 * (gx2 * x2 + gy2 * y2 + gz2 * z2);
}
t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
if (t3 < 0.0) {
n3 = t3 = t23 = t43 = gx3 = gy3 = gz3 = 0.0;
} else {
grad3(v3_array, perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]]);
gx3 = v3_array[0];
gy3 = v3_array[1];
gz3 = v3_array[2];
t23 = t3 * t3;
t43 = t23 * t23;
n3 = t43 * (gx3 * x3 + gy3 * y3 + gz3 * z3);
}
/* Add contributions from each corner to get the final noise value.
* The result is scaled to return values in the range [-1,1] */
const noise = 28.0 * (n0 + n1 + n2 + n3);
/* Compute derivative, if requested by supplying non-null pointers
* for the last three arguments */
/* A straight, unoptimised calculation would be like:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gx0;
* *dnoise_dy = -8.0f * t20 * t0 * y0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gy0;
* *dnoise_dz = -8.0f * t20 * t0 * z0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gz0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gx1;
* *dnoise_dy += -8.0f * t21 * t1 * y1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gy1;
* *dnoise_dz += -8.0f * t21 * t1 * z1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gz1;
* *dnoise_dx += -8.0f * t22 * t2 * x2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gx2;
* *dnoise_dy += -8.0f * t22 * t2 * y2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gy2;
* *dnoise_dz += -8.0f * t22 * t2 * z2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gz2;
* *dnoise_dx += -8.0f * t23 * t3 * x3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gx3;
* *dnoise_dy += -8.0f * t23 * t3 * y3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gy3;
* *dnoise_dz += -8.0f * t23 * t3 * z3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gz3;
*/
const temp0 = t20 * t0 * (gx0 * x0 + gy0 * y0 + gz0 * z0);
let dnoise_dx = temp0 * x0;
let dnoise_dy = temp0 * y0;
let dnoise_dz = temp0 * z0;
const temp1 = t21 * t1 * (gx1 * x1 + gy1 * y1 + gz1 * z1);
dnoise_dx += temp1 * x1;
dnoise_dy += temp1 * y1;
dnoise_dz += temp1 * z1;
const temp2 = t22 * t2 * (gx2 * x2 + gy2 * y2 + gz2 * z2);
dnoise_dx += temp2 * x2;
dnoise_dy += temp2 * y2;
dnoise_dz += temp2 * z2;
const temp3 = t23 * t3 * (gx3 * x3 + gy3 * y3 + gz3 * z3);
dnoise_dx += temp3 * x3;
dnoise_dy += temp3 * y3;
dnoise_dz += temp3 * z3;
dnoise_dx *= -8.0;
dnoise_dy *= -8.0;
dnoise_dz *= -8.0;
dnoise_dx += t40 * gx0 + t41 * gx1 + t42 * gx2 + t43 * gx3;
dnoise_dy += t40 * gy0 + t41 * gy1 + t42 * gy2 + t43 * gy3;
dnoise_dz += t40 * gz0 + t41 * gz1 + t42 * gz2 + t43 * gz3;
/* Scale derivative to match the noise scaling */
dnoise_dx *= 28.0;
dnoise_dy *= 28.0;
dnoise_dz *= 28.0;
derivatives[0] = dnoise_dx;
derivatives[1] = dnoise_dy;
derivatives[2] = dnoise_dz;
return noise;
}
// The skewing and unskewing factors are hairy again for the 4D case
const F4 = 0.30901699437494745;// F4 = (Math.sqrt(5.0)-1.0)/4.0
const G4 = 0.1381966011250105; // G4 = (5.0-Math.sqrt(5.0))/20.0
/**
* 4D simplex noise with derivatives.
* If the last four arguments are not null, the analytic derivative
* (the 4D gradient of the scalar noise field) is also calculated.
* @param {number[]} derivatives
* @param {number} x
* @param {number} y
* @param {number} z
* @param {number} w
* @returns {number}
*/
export function sdnoise4(derivatives, x, y, z, w) {
let n0, n1, n2, n3, n4; // Noise contributions from the five corners
let noise; // Return value
let gx0, gy0, gz0, gw0, gx1, gy1, gz1, gw1; /* Gradients at simplex corners */
let gx2, gy2, gz2, gw2, gx3, gy3, gz3, gw3, gx4, gy4, gz4, gw4;
let t20, t21, t22, t23, t24;
let t40, t41, t42, t43, t44;
let x1, y1, z1, w1, x2, y2, z2, w2, x3, y3, z3, w3, x4, y4, z4, w4;
let t0, t1, t2, t3, t4;
let temp0, temp1, temp2, temp3, temp4;
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
const s = (x + y + z + w) * F4; // Factor for 4D skewing
const xs = x + s;
const ys = y + s;
const zs = z + s;
const ws = w + s;
let ii, i = xs | 0;
let jj, j = ys | 0;
let kk, k = zs | 0;
let ll, l = ws | 0;
const t = (i + j + k + l) * G4; // Factor for 4D unskewing
const X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
const Y0 = j - t;
const Z0 = k - t;
const W0 = l - t;
const x0 = x - X0; // The x,y,z,w distances from the cell origin
const y0 = y - Y0;
const z0 = z - Z0;
const w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// The method below is a reasonable way of finding the ordering of x,y,z,w
// and then find the correct traversal order for the simplex we�re in.
// First, six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and then the results are used to add up binary
// bits for an integer index into a precomputed lookup table, simplex[].
const c1 = (x0 > y0) ? 32 : 0;
const c2 = (x0 > z0) ? 16 : 0;
const c3 = (y0 > z0) ? 8 : 0;
const c4 = (x0 > w0) ? 4 : 0;
const c5 = (y0 > w0) ? 2 : 0;
const c6 = (z0 > w0) ? 1 : 0;
const c = c1 | c2 | c3 | c4 | c5 | c6; // '|' is mostly faster than '+'
let i1, j1, k1, l1; // The integer offsets for the second simplex corner
let i2, j2, k2, l2; // The integer offsets for the third simplex corner
let i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// The number 3 in the "simplex" array is at the position of the largest coordinate.
const simplex_c = simplex[c];
const simplex_c_0 = simplex_c[0];
const simplex_c_1 = simplex_c[1];
const simplex_c_2 = simplex_c[2];
const simplex_c_3 = simplex_c[3];
i1 = simplex_c_0 >= 3 ? 1 : 0;
j1 = simplex_c_1 >= 3 ? 1 : 0;
k1 = simplex_c_2 >= 3 ? 1 : 0;
l1 = simplex_c_3 >= 3 ? 1 : 0;
// The number 2 in the "simplex" array is at the second largest coordinate.
i2 = simplex_c_0 >= 2 ? 1 : 0;
j2 = simplex_c_1 >= 2 ? 1 : 0;
k2 = simplex_c_2 >= 2 ? 1 : 0;
l2 = simplex_c_3 >= 2 ? 1 : 0;
// The number 1 in the "simplex" array is at the second smallest coordinate.
i3 = simplex_c_0 >= 1 ? 1 : 0;
j3 = simplex_c_1 >= 1 ? 1 : 0;
k3 = simplex_c_2 >= 1 ? 1 : 0;
l3 = simplex_c_3 >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to look that up.
x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
y1 = y0 - j1 + G4;
z1 = z0 - k1 + G4;
w1 = w0 - l1 + G4;
x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
y2 = y0 - j2 + 2.0 * G4;
z2 = z0 - k2 + 2.0 * G4;
w2 = w0 - l2 + 2.0 * G4;
x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
y3 = y0 - j3 + 3.0 * G4;
z3 = z0 - k3 + 3.0 * G4;
w3 = w0 - l3 + 3.0 * G4;
x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
y4 = y0 - 1.0 + 4.0 * G4;
z4 = z0 - 1.0 + 4.0 * G4;
w4 = w0 - 1.0 + 4.0 * G4;
// Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
ii = i & 0xff;
jj = j & 0xff;
kk = k & 0xff;
ll = l & 0xff;
// Calculate the contribution from the five corners
t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
if (t0 < 0.0) {
n0 = t0 = t20 = t40 = gx0 = gy0 = gz0 = gw0 = 0.0;
} else {
t20 = t0 * t0;
t40 = t20 * t20;
grad4(v4_array, perm[ii + perm[jj + perm[kk + perm[ll]]]]);
gx0 = v4_array[0];
gy0 = v4_array[1];
gz0 = v4_array[2];
gw0 = v4_array[3];
n0 = t40 * (gx0 * x0 + gy0 * y0 + gz0 * z0 + gw0 * w0);
}
t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
if (t1 < 0.0) {
n1 = t1 = t21 = t41 = gx1 = gy1 = gz1 = gw1 = 0.0;
} else {
t21 = t1 * t1;
t41 = t21 * t21;
grad4(v4_array, perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]]);
gx1 = v4_array[0];
gy1 = v4_array[1];
gz1 = v4_array[2];
gw1 = v4_array[3];
n1 = t41 * (gx1 * x1 + gy1 * y1 + gz1 * z1 + gw1 * w1);
}
t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
if (t2 < 0.0) {
n2 = t2 = t22 = t42 = gx2 = gy2 = gz2 = gw2 = 0.0;
} else {
t22 = t2 * t2;
t42 = t22 * t22;
grad4(v4_array, perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]]);
gx2 = v4_array[0];
gy2 = v4_array[1];
gz2 = v4_array[2];
gw2 = v4_array[3];
n2 = t42 * (gx2 * x2 + gy2 * y2 + gz2 * z2 + gw2 * w2);
}
t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
if (t3 < 0.0) {
n3 = t3 = t23 = t43 = gx3 = gy3 = gz3 = gw3 = 0.0;
} else {
t23 = t3 * t3;
t43 = t23 * t23;
grad4(v4_array, perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]]);
gx3 = v4_array[0];
gy3 = v4_array[1];
gz3 = v4_array[2];
gw3 = v4_array[3];
n3 = t43 * (gx3 * x3 + gy3 * y3 + gz3 * z3 + gw3 * w3);
}
t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
if (t4 < 0.0) {
n4 = t4 = t24 = t44 = gx4 = gy4 = gz4 = gw4 = 0.0;
} else {
t24 = t4 * t4;
t44 = t24 * t24;
grad4(v4_array, perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]]);
gx4 = v4_array[0];
gy4 = v4_array[1];
gz4 = v4_array[2];
gw4 = v4_array[3];
n4 = t44 * (gx4 * x4 + gy4 * y4 + gz4 * z4 + gw4 * w4);
}
// Sum up and scale the result to cover the range [-1,1]
noise = 27.0 * (n0 + n1 + n2 + n3 + n4); // TODO: The scale factor is preliminary!
/* Compute derivative, if requested by supplying non-null pointers
* for the last four arguments */
/* A straight, unoptimised calculation would be like:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * dot(gx0, gy0, gz0, gw0, x0, y0, z0, w0) + t40 * gx0;
* *dnoise_dy = -8.0f * t20 * t0 * y0 * dot(gx0, gy0, gz0, gw0, x0, y0, z0, w0) + t40 * gy0;
* *dnoise_dz = -8.0f * t20 * t0 * z0 * dot(gx0, gy0, gz0, gw0, x0, y0, z0, w0) + t40 * gz0;
* *dnoise_dw = -8.0f * t20 * t0 * w0 * dot(gx0, gy0, gz0, gw0, x0, y0, z0, w0) + t40 * gw0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * dot(gx1, gy1, gz1, gw1, x1, y1, z1, w1) + t41 * gx1;
* *dnoise_dy += -8.0f * t21 * t1 * y1 * dot(gx1, gy1, gz1, gw1, x1, y1, z1, w1) + t41 * gy1;
* *dnoise_dz += -8.0f * t21 * t1 * z1 * dot(gx1, gy1, gz1, gw1, x1, y1, z1, w1) + t41 * gz1;
* *dnoise_dw = -8.0f * t21 * t1 * w1 * dot(gx1, gy1, gz1, gw1, x1, y1, z1, w1) + t41 * gw1;
* *dnoise_dx += -8.0f * t22 * t2 * x2 * dot(gx2, gy2, gz2, gw2, x2, y2, z2, w2) + t42 * gx2;
* *dnoise_dy += -8.0f * t22 * t2 * y2 * dot(gx2, gy2, gz2, gw2, x2, y2, z2, w2) + t42 * gy2;
* *dnoise_dz += -8.0f * t22 * t2 * z2 * dot(gx2, gy2, gz2, gw2, x2, y2, z2, w2) + t42 * gz2;
* *dnoise_dw += -8.0f * t22 * t2 * w2 * dot(gx2, gy2, gz2, gw2, x2, y2, z2, w2) + t42 * gw2;
* *dnoise_dx += -8.0f * t23 * t3 * x3 * dot(gx3, gy3, gz3, gw3, x3, y3, z3, w3) + t43 * gx3;
* *dnoise_dy += -8.0f * t23 * t3 * y3 * dot(gx3, gy3, gz3, gw3, x3, y3, z3, w3) + t43 * gy3;
* *dnoise_dz += -8.0f * t23 * t3 * z3 * dot(gx3, gy3, gz3, gw3, x3, y3, z3, w3) + t43 * gz3;
* *dnoise_dw += -8.0f * t23 * t3 * w3 * dot(gx3, gy3, gz3, gw3, x3, y3, z3, w3) + t43 * gw3;
* *dnoise_dx += -8.0f * t24 * t4 * x4 * dot(gx4, gy4, gz4, gw4, x4, y4, z4, w4) + t44 * gx4;
* *dnoise_dy += -8.0f * t24 * t4 * y4 * dot(gx4, gy4, gz4, gw4, x4, y4, z4, w4) + t44 * gy4;
* *dnoise_dz += -8.0f * t24 * t4 * z4 * dot(gx4, gy4, gz4, gw4, x4, y4, z4, w4) + t44 * gz4;
* *dnoise_dw += -8.0f * t24 * t4 * w4 * dot(gx4, gy4, gz4, gw4, x4, y4, z4, w4) + t44 * gw4;
*/
temp0 = t20 * t0 * (gx0 * x0 + gy0 * y0 + gz0 * z0 + gw0 * w0);
let dnoise_dx = temp0 * x0;
let dnoise_dy = temp0 * y0;
let dnoise_dz = temp0 * z0;
let dnoise_dw = temp0 * w0;
temp1 = t21 * t1 * (gx1 * x1 + gy1 * y1 + gz1 * z1 + gw1 * w1);
dnoise_dx += temp1 * x1;
dnoise_dy += temp1 * y1;
dnoise_dz += temp1 * z1;
dnoise_dw += temp1 * w1;
temp2 = t22 * t2 * (gx2 * x2 + gy2 * y2 + gz2 * z2 + gw2 * w2);
dnoise_dx += temp2 * x2;
dnoise_dy += temp2 * y2;
dnoise_dz += temp2 * z2;
dnoise_dw += temp2 * w2;
temp3 = t23 * t3 * (gx3 * x3 + gy3 * y3 + gz3 * z3 + gw3 * w3);
dnoise_dx += temp3 * x3;
dnoise_dy += temp3 * y3;
dnoise_dz += temp3 * z3;
dnoise_dw += temp3 * w3;
temp4 = t24 * t4 * (gx4 * x4 + gy4 * y4 + gz4 * z4 + gw4 * w4);
dnoise_dx += temp4 * x4;
dnoise_dy += temp4 * y4;
dnoise_dz += temp4 * z4;
dnoise_dw += temp4 * w4;
dnoise_dx *= -8.0;
dnoise_dy *= -8.0;
dnoise_dz *= -8.0;
dnoise_dw *= -8.0;
dnoise_dx += t40 * gx0 + t41 * gx1 + t42 * gx2 + t43 * gx3 + t44 * gx4;
dnoise_dy += t40 * gy0 + t41 * gy1 + t42 * gy2 + t43 * gy3 + t44 * gy4;
dnoise_dz += t40 * gz0 + t41 * gz1 + t42 * gz2 + t43 * gz3 + t44 * gz4;
dnoise_dw += t40 * gw0 + t41 * gw1 + t42 * gw2 + t43 * gw3 + t44 * gw4;
dnoise_dx *= 28.0; /* Scale derivative to match the noise scaling */
dnoise_dy *= 28.0;
dnoise_dz *= 28.0;
dnoise_dw *= 28.0;
derivatives[0] = dnoise_dx;
derivatives[1] = dnoise_dy;
derivatives[2] = dnoise_dz;
derivatives[3] = dnoise_dw;
return noise;
}