@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/Random.js

@@ -0,0 +1,543 @@
+/**
+ * @internal
+ * 均匀实数分布函数
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 区间[min,max]内的随机数
+ */
+export function uniform_real_distribution(min, max) {
+    return (Math.random() * max + Math.random() * min + (max - min) * Math.random());
+}
+/**
+ * @internal
+ * 带随机数生成器的均匀实数分布
+ * @param min 最小值
+ * @param max 最大值
+ * @param rng 随机数生成器
+ * @returns 区间[min,max]内的随机数
+ */
+export function uniform_real_distribution2(min, max, rng) {
+    let rd = rng * Math.random();
+    return (Math.random() * max * rd +
+        Math.random() * min * rd +
+        (max - min) * Math.random() * rd);
+}
+/**
+ * @internal
+ * 正态(高斯)分布函数
+ * @param min 最小值
+ * @param max 最大值
+ * @param skew 偏度系数
+ * @returns 符合正态分布的随机数
+ */
+export function normal_distribution(min, max, skew) {
+    let u = 0, v = 0;
+    while (u === 0)
+        u = Math.random(); //Converting [0,1) to (0,1)
+    while (v === 0)
+        v = Math.random();
+    let num = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+    num = num / 10.0 + 0.5; // Translate to 0 -> 1
+    if (num > 1 || num < 0)
+        num = normal_distribution(min, max, skew); // resample between 0 and 1 if out of range
+    num = Math.pow(num, skew); // Skew
+    num *= max - min; // Stretch to fill range
+    num += min; // offset to min
+    return num;
+}
+/*
+ * 本实现是Ken Perlin在Siggraph 2001"实时着色"课程中提出的"Simplex噪声"算法，
+ */
+export function FASTFLOOR(x) {
+    return x > 0 ? Math.floor(x) : Math.floor(x) - 1;
+}
+/*
+ * 排列表：这是0-255所有数字的随机乱序排列，重复两次以避免每次查找时在255处回绕。
+ * 该表在所有平台的所有实例中必须完全一致，因此最简单的做法是将其保留为静态显式数据。
+ * 这也消除了对此类进行初始化的需要。
+ *
+ * 注意：在需要对非对齐单字节寻址惩罚较高的平台上，使用int[]而非char[]可能使代码运行更快。
+ * Intel x86架构通常对单字节友好，但其他一些CPU使用4字节对齐读取更快。
+ * 但char[]更小，可避免缓存抖动，这在大多数架构上可能是最重要的考量因素。
+ * 噪声函数会频繁访问此数组——3D向量噪声访问96次，4D浮点噪声访问64次，
+ * 因此我们希望它能够放入缓存！
+ */
+/**
+ * @internal
+ */
+export let perm = [
+    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,
+];
+/*
+ * 辅助函数：计算梯度向量与残差向量的点积（1D到4D）
+ * 注意：这些函数生成的梯度长度大于单位长度。为了与经典Perlin噪声的值域紧密匹配，
+ * 最终噪声值需要重新缩放以适应[-1,1]范围。
+ * （Simplex噪声函数本身也有不同的缩放比例。）
+ * 还需注意：这些噪声函数是Perlin噪声最实用、最有用的有符号版本。
+ * 若要按照RenderMan规范从SL noise()和pnoise()函数返回值，
+ * 需要将噪声值缩放和偏移到[0,1]范围，例如：
+ * float SLnoise = (noise(x,y,z) + 1.0) * 0.5;
+ */
+/**
+ * @internal
+ */
+export function grad1(hash, x) {
+    let h = hash & 15;
+    let grad = 1.0 + (h & 7); // Gradient value 1.0, 2.0, ..., 8.0
+    if (h & 8)
+        grad = -grad; // Set a random sign for the gradient
+    return grad * x; // Multiply the gradient with the distance
+}
+/**
+ * @internal
+ */
+export function grad2(hash, x, y) {
+    let h = hash & 7; // Convert low 3 bits of hash code
+    let u = h < 4 ? x : y; // into 8 simple gradient directions,
+    let v = h < 4 ? y : x; // and compute the dot product with (x,y).
+    return (h & 1 ? -u : u) + (h & 2 ? -2.0 * v : 2.0 * v);
+}
+/**
+ * @internal
+ */
+export function grad3(hash, x, y, z) {
+    let h = hash & 15; // Convert low 4 bits of hash code into 12 simple
+    let u = h < 8 ? x : y; // gradient directions, and compute dot product.
+    let v = h < 4 ? y : h == 12 || h == 14 ? x : z; // Fix repeats at h = 12 to 15
+    return (h & 1 ? -u : u) + (h & 2 ? -v : v);
+}
+/**
+ * @internal
+ */
+export function grad4(hash, x, y, z, t) {
+    let h = hash & 31; // Convert low 5 bits of hash code into 32 simple
+    let u = h < 24 ? x : y; // gradient directions, and compute dot product.
+    let v = h < 16 ? y : z;
+    let w = h < 8 ? z : t;
+    return (h & 1 ? -u : u) + (h & 2 ? -v : v) + (h & 4 ? -w : w);
+}
+/**
+ * @internal
+ */
+export let simplex = [
+    [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],
+];
+/**
+ * @internal
+ */
+export function snoise1(x) {
+    let i0 = FASTFLOOR(x);
+    let i1 = i0 + 1;
+    let x0 = x - i0;
+    let x1 = x0 - 1.0;
+    let n0, n1;
+    let t0 = 1.0 - x0 * x0;
+    t0 *= t0;
+    n0 = t0 * t0 * grad1(perm[i0 & 0xff], x0);
+    let t1 = 1.0 - x1 * x1;
+    t1 *= t1;
+    n1 = t1 * t1 * grad1(perm[i1 & 0xff], x1);
+    return 0.25 * (n0 + n1);
+}
+/**
+ * @internal
+ */
+export function snoise2(x, y) {
+    const F2 = 0.366025403; // F2 = 0.5*(sqrt(3.0)-1.0)
+    const G2 = 0.211324865; // G2 = (3.0-Math.sqrt(3.0))/6.0
+    let n0, n1, n2; // Noise contributions from the three corners
+    // Skew the input space to determine which simplex cell we're in
+    let s = (x + y) * F2; // Hairy factor for 2D
+    let xs = x + s;
+    let ys = y + s;
+    let i = FASTFLOOR(xs);
+    let j = FASTFLOOR(ys);
+    let t = (i + j) * G2;
+    let X0 = i - t; // Unskew the cell origin back to (x,y) space
+    let Y0 = j - t;
+    let x0 = x - X0; // The x,y distances from the cell origin
+    let y0 = y - Y0;
+    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)
+    let x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+    let y1 = y0 - j1 + G2;
+    let x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+    let y2 = y0 - 1.0 + 2.0 * G2;
+    // Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
+    let ii = i & 0xff;
+    let jj = j & 0xff;
+    // Calculate the contribution from the three corners
+    let t0 = 0.5 - x0 * x0 - y0 * y0;
+    if (t0 < 0.0)
+        n0 = 0.0;
+    else {
+        t0 *= t0;
+        n0 = t0 * t0 * grad2(perm[ii + perm[jj]], x0, y0);
+    }
+    let t1 = 0.5 - x1 * x1 - y1 * y1;
+    if (t1 < 0.0)
+        n1 = 0.0;
+    else {
+        t1 *= t1;
+        n1 = t1 * t1 * grad2(perm[ii + i1 + perm[jj + j1]], x1, y1);
+    }
+    let t2 = 0.5 - x2 * x2 - y2 * y2;
+    if (t2 < 0.0)
+        n2 = 0.0;
+    else {
+        t2 *= t2;
+        n2 = t2 * t2 * grad2(perm[ii + 1 + perm[jj + 1]], x2, y2);
+    }
+    return 40.0 * (n0 + n1 + n2);
+}
+// 3D simplex noise
+/**
+ * @internal
+ */
+export function snoise3(x, y, z) {
+    const F3 = 0.333333333;
+    const G3 = 0.166666667;
+    let n0, n1, n2, n3;
+    let s = (x + y + z) * F3;
+    let xs = x + s;
+    let ys = y + s;
+    let zs = z + s;
+    let i = FASTFLOOR(xs);
+    let j = FASTFLOOR(ys);
+    let k = FASTFLOOR(zs);
+    let t = (i + j + k) * G3;
+    let X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+    let Y0 = j - t;
+    let Z0 = k - t;
+    let x0 = x - X0; // The x,y,z distances from the cell origin
+    let y0 = y - Y0;
+    let z0 = z - Z0;
+    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
+    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
+    }
+    let x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+    let y1 = y0 - j1 + G3;
+    let z1 = z0 - k1 + G3;
+    let x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+    let y2 = y0 - j2 + 2.0 * G3;
+    let z2 = z0 - k2 + 2.0 * G3;
+    let x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+    let y3 = y0 - 1.0 + 3.0 * G3;
+    let z3 = z0 - 1.0 + 3.0 * G3;
+    let ii = i & 0xff;
+    let jj = j & 0xff;
+    let kk = k & 0xff;
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+    if (t0 < 0.0)
+        n0 = 0.0;
+    else {
+        t0 *= t0;
+        n0 = t0 * t0 * grad3(perm[ii + perm[jj + perm[kk]]], x0, y0, z0);
+    }
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+    if (t1 < 0.0)
+        n1 = 0.0;
+    else {
+        t1 *= t1;
+        n1 =
+            t1 *
+                t1 *
+                grad3(perm[ii + i1 + perm[jj + j1 + perm[kk + k1]]], x1, y1, z1);
+    }
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+    if (t2 < 0.0)
+        n2 = 0.0;
+    else {
+        t2 *= t2;
+        n2 =
+            t2 *
+                t2 *
+                grad3(perm[ii + i2 + perm[jj + j2 + perm[kk + k2]]], x2, y2, z2);
+    }
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+    if (t3 < 0.0)
+        n3 = 0.0;
+    else {
+        t3 *= t3;
+        n3 =
+            t3 * t3 * grad3(perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]], x3, y3, z3);
+    }
+    return 32.0 * (n0 + n1 + n2 + n3); // TODO: The scale factor is preliminary!
+}
+// 4D simplex noise
+/**
+ * @internal
+ */
+export function snoise4(x, y, z, w) {
+    const F4 = 0.309016994; // F4 = (Math.sqrt(5.0)-1.0)/4.0
+    const G4 = 0.138196601; // G4 = (5.0-Math.sqrt(5.0))/20.0
+    let n0, n1, n2, n3, n4; // Noise contributions from the five corners
+    let s = (x + y + z + w) * F4; // Factor for 4D skewing
+    let xs = x + s;
+    let ys = y + s;
+    let zs = z + s;
+    let ws = w + s;
+    let i = FASTFLOOR(xs);
+    let j = FASTFLOOR(ys);
+    let k = FASTFLOOR(zs);
+    let l = FASTFLOOR(ws);
+    let t = (i + j + k + l) * G4; // Factor for 4D unskewing
+    let X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+    let Y0 = j - t;
+    let Z0 = k - t;
+    let W0 = l - t;
+    let x0 = x - X0; // The x,y,z,w distances from the cell origin
+    let y0 = y - Y0;
+    let z0 = z - Z0;
+    let w0 = w - W0;
+    let c1 = x0 > y0 ? 32 : 0;
+    let c2 = x0 > z0 ? 16 : 0;
+    let c3 = y0 > z0 ? 8 : 0;
+    let c4 = x0 > w0 ? 4 : 0;
+    let c5 = y0 > w0 ? 2 : 0;
+    let c6 = z0 > w0 ? 1 : 0;
+    let c = c1 + c2 + c3 + c4 + c5 + c6;
+    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
+    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.
+    let x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+    let y1 = y0 - j1 + G4;
+    let z1 = z0 - k1 + G4;
+    let w1 = w0 - l1 + G4;
+    let x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+    let y2 = y0 - j2 + 2.0 * G4;
+    let z2 = z0 - k2 + 2.0 * G4;
+    let w2 = w0 - l2 + 2.0 * G4;
+    let x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+    let y3 = y0 - j3 + 3.0 * G4;
+    let z3 = z0 - k3 + 3.0 * G4;
+    let w3 = w0 - l3 + 3.0 * G4;
+    let x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+    let y4 = y0 - 1.0 + 4.0 * G4;
+    let z4 = z0 - 1.0 + 4.0 * G4;
+    let w4 = w0 - 1.0 + 4.0 * G4;
+    // Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
+    let ii = i & 0xff;
+    let jj = j & 0xff;
+    let kk = k & 0xff;
+    let ll = l & 0xff;
+    // Calculate the contribution from the five corners
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+    if (t0 < 0.0)
+        n0 = 0.0;
+    else {
+        t0 *= t0;
+        n0 =
+            t0 *
+                t0 *
+                grad4(perm[ii + perm[jj + perm[kk + perm[ll]]]], x0, y0, z0, w0);
+    }
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+    if (t1 < 0.0)
+        n1 = 0.0;
+    else {
+        t1 *= t1;
+        n1 =
+            t1 *
+                t1 *
+                grad4(perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]], x1, y1, z1, w1);
+    }
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+    if (t2 < 0.0)
+        n2 = 0.0;
+    else {
+        t2 *= t2;
+        n2 =
+            t2 *
+                t2 *
+                grad4(perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]], x2, y2, z2, w2);
+    }
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+    if (t3 < 0.0)
+        n3 = 0.0;
+    else {
+        t3 *= t3;
+        n3 =
+            t3 *
+                t3 *
+                grad4(perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]], x3, y3, z3, w3);
+    }
+    let t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+    if (t4 < 0.0)
+        n4 = 0.0;
+    else {
+        t4 *= t4;
+        n4 =
+            t4 *
+                t4 *
+                grad4(perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]], x4, y4, z4, w4);
+    }
+    return 27.0 * (n0 + n1 + n2 + n3 + n4);
+}

package/dist/src/math/Ray.d.ts

@@ -0,0 +1,41 @@
+import { IBound } from "../core/bound/IBound";
+import { Triangle } from "./Triangle";
+import { Matrix4 } from "./Matrix4";
+import { Vector3 } from "./Vector3";
+export declare class Ray {
+    origin: Vector3;
+    length: number;
+    private static _rayl;
+    private static _smallnum;
+    private _vector;
+    private _dir;
+    constructor(origin?: Vector3, dir?: Vector3);
+    get direction(): Vector3;
+    set direction(dir: Vector3);
+    clone(): Ray;
+    intersectBox(box: IBound, target?: Vector3): Vector3;
+    pointAt(t: number, target?: Vector3): Vector3;
+    copy(src: Ray): this;
+    setApproxDirection(dir: Vector3): void;
+    setOrigin(origin: Vector3): void;
+    getOrigin(): Vector3;
+    getPoint(t: number): Vector3;
+    sqrDistToPoint(P: Vector3): number;
+    applyMatrix(mat4: Matrix4): void;
+    private _v0;
+    private _v1;
+    private _v2;
+    pointInTriangle(P: Vector3, A: Vector3, B: Vector3, C: Vector3): boolean;
+    private _E1;
+    private _E2;
+    private _P;
+    private _T;
+    private _Q;
+    intersectTriangle(orig: Vector3, dir: Vector3, face: Triangle): Vector3;
+    intersectSphere(o: Vector3, dir: Vector3, center: Vector3, radius: number): Vector3;
+    intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): {
+        out: Vector3;
+        length: number;
+    };
+    private get_vec;
+}