@woosh/meep-engine 2.46.0 → 2.46.2

package/src/core/math/noise/sdnoise.js

@@ -1,952 +0,0 @@
-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}
- */
-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
-    f - 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
-    f - 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}
- */
-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 = (float)(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;
-}