@woosh/meep-engine 2.109.0 → 2.109.2

package/src/core/geom/3d/eulerAnglesFromMatrix.js

@@ -1,10 +1,5 @@
-//
-
 import { v2_magnitude } from "../vec2/v2_magnitude.js";
 
-function atan2(a, b) {
-    return Math.atan2(a, b);
-}
 
 /**
  *
@@ -17,15 +12,9 @@ function coeff(mat4, row_index, column_index) {
     return mat4[row_index + column_index * 4];
 }
 
-function sin(a) {
-    return Math.sin(a);
-}
-
-function cos(a) {
-    return Math.cos(a);
-}
-
-const EIGEN_PI = Math.PI;
+const sin = Math.sin;
+const cos = Math.cos;
+const atan2 = Math.atan2;
 
 /**
  *
@@ -50,10 +39,14 @@ const EIGEN_PI = Math.PI;
  * @param {number[]} res
  * @param {number[]|Float32Array|mat4} m4
  * @param {number} a0 axis index
- * @param {number} a1
- * @param {number} a2
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
  */
-export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
+export function eulerAnglesFromMatrix(
+    res, m4,
+    a0, a1, a2
+) {
+
     const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
 
     const i = a0;
@@ -62,11 +55,12 @@ export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
     if (a0 === a2) {
         res[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
             res[1] = -atan2(s2, coeff(m4, i, i));
@@ -87,25 +81,34 @@ export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     } else {
+
         res[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+
         const c2 = v2_magnitude(coeff(m4, i, i), coeff(m4, i, j));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             res[1] = atan2(-coeff(m4, i, k), -c2);
-        } else
+        } else {
             res[1] = atan2(-coeff(m4, i, k), c2);
+        }
+
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     }
 
-    if (!odd) {
+    if (odd === 0) {
         // invert result
         res[0] = -res[0];
         res[1] = -res[1];

package/src/core/geom/3d/morton/v3_morton_encode_bounded.d.ts

@@ -2,8 +2,8 @@
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} bounds
+ * @param {number[]|AABB3} bounds
  * @returns {number}
  */
-export function v3_morton_encode_bounded(x: number, y: number, z: number, bounds: number[]): number;
+export function v3_morton_encode_bounded(x: number, y: number, z: number, bounds: number[] | AABB3): number;
 //# sourceMappingURL=v3_morton_encode_bounded.d.ts.map

package/src/core/geom/3d/morton/v3_morton_encode_bounded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_morton_encode_bounded.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/v3_morton_encode_bounded.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GACN,MAAM,CA0BlB"}
+{"version":3,"file":"v3_morton_encode_bounded.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/v3_morton_encode_bounded.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAAM,GACZ,MAAM,CA0BlB"}

package/src/core/geom/3d/morton/v3_morton_encode_bounded.js

@@ -4,7 +4,7 @@ import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} bounds
+ * @param {number[]|AABB3} bounds
  * @returns {number}
  */
 export function v3_morton_encode_bounded(x, y, z, bounds) {

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts

@@ -1,10 +1,10 @@
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]} output
+ * @param {number[]|Vector3} output
  * @param {number} output_offset
  * @param {number} x range [0,1]
  * @param {number} y range [0,1]
  */
-export function decode_octahedron_to_unit(output: number[], output_offset: number, x: number, y: number): void;
+export function decode_octahedron_to_unit(output: number[] | Vector3, output_offset: number, x: number, y: number): void;
 //# sourceMappingURL=decode_octahedron_to_unit.d.ts.map

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB"}
+{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,UAAQ,iBAChB,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB"}

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js

@@ -3,7 +3,7 @@ import { sign_not_zero } from "../../../../math/sign_not_zero.js";
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]} output
+ * @param {number[]|Vector3} output
  * @param {number} output_offset
  * @param {number} x range [0,1]
  * @param {number} y range [0,1]

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.js

@@ -1,4 +1,4 @@
-import { v3_shift_along_direction } from "../../vec3/v3_shift_along_direction.js";
+import { v3_array_displace_in_direction } from "../../vec3/v3_array_displace_in_direction.js";
 
 /**
  *
@@ -21,7 +21,7 @@ export function ray3_shift_origin_along_direction(
     const direction_y = input[input_offset + 4];
     const direction_z = input[input_offset + 5];
 
-    v3_shift_along_direction(
+    v3_array_displace_in_direction(
         output, 0,
         origin_x, origin_y, origin_z,
         direction_x, direction_y, direction_z,

package/src/core/geom/3d/sphere/harmonics/sh3_convolve_with_cosine_kernel.js

@@ -22,4 +22,5 @@ export function sh3_convolve_with_cosine_kernel(out, out_offset, input, input_of
     out[out_offset + 6] = input[input_offset + 6] * CosineA2;
     out[out_offset + 7] = input[input_offset + 7] * CosineA2;
     out[out_offset + 8] = input[input_offset + 8] * CosineA2;
-}
+}
+

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} basis
+ * @param {number} basis_offset
+ * @param {number[]|Float32Array|Float64Array} vector
+ * @param {number} vector_offset
+ * @param {number} dimensions
+ */
+export function sh3_vector_accumulate(out: number[] | Float32Array | Float64Array, out_offset: number, basis: number[] | Float32Array | Float64Array, basis_offset: number, vector: number[] | Float32Array | Float64Array, vector_offset: number, dimensions: number): void;
+//# sourceMappingURL=sh3_vector_accumulate.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_vector_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,2CARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,cACN,MAAM,QA6BhB"}

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.js

@@ -0,0 +1,40 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} basis
+ * @param {number} basis_offset
+ * @param {number[]|Float32Array|Float64Array} vector
+ * @param {number} vector_offset
+ * @param {number} dimensions
+ */
+export function sh3_vector_accumulate(
+    out, out_offset,
+    basis, basis_offset,
+    vector, vector_offset, dimensions
+) {
+
+    assert.isArrayLike(out, 'out');
+    assert.isNonNegativeInteger(out_offset, 'out_offset');
+
+    assert.isArrayLike(basis, 'basis');
+    assert.isNonNegativeInteger(basis_offset, 'basis_offset');
+
+    assert.isNonNegativeInteger(dimensions, 'dimensions');
+
+    for (let j = 0; j < 9; j++) {
+
+        const out_coefficient_offset = out_offset + j * dimensions;
+
+        const basis_value = basis[basis_offset + j];
+
+        for (let i = 0; i < dimensions; i++) {
+            const scalar = vector[vector_offset + i];
+
+            out[out_coefficient_offset + i] += basis_value * scalar;
+        }
+
+    }
+}

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sh3_vector_accumulate.spec.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_vector_accumulate.spec.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.spec.js"],"names":[],"mappings":""}

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.spec.js

@@ -0,0 +1,27 @@
+import { sh3_vector_accumulate } from "./sh3_vector_accumulate.js";
+
+test("basics", () => {
+    const out = [
+        1, 2,
+        3,4, 5,6,7,8,
+        9,10, 11,12, 13,14, 15,16, 17,18
+    ];
+    const basis = [
+        2,
+        3, 5, 7,
+        11, 13, 17, 19, 23
+    ];
+
+    sh3_vector_accumulate(
+        out, 0,
+        basis, 0,
+        [-3, 5], 0,
+        2
+    );
+
+    expect(out).toEqual([
+        -5, 12,
+        -6, 19, -10, 31, -14, 43,
+        -24, 65, -28, 77, -38, 99, -42, 111, -52, 133
+    ]);
+});

package/src/core/geom/3d/sphere/sphere_intersects_ray.js

@@ -48,4 +48,4 @@ export function sphere_intersects_ray(
     }
 
     return true;
-}
+}

package/src/core/geom/3d/tetrahedra/tetrahedron_compute_circumsphere.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedron_compute_circumsphere.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_compute_circumsphere.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,yDAPW,MAAM,EAAE,UACR,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA+EhB"}
+{"version":3,"file":"tetrahedron_compute_circumsphere.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_compute_circumsphere.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;AACH,yDAPW,MAAM,EAAE,UACR,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA2EhB"}

package/src/core/geom/3d/tetrahedra/tetrahedron_compute_circumsphere.js

@@ -1,9 +1,20 @@
 import { array_copy } from "../../../collection/array/array_copy.js";
+import { solve_linear_system } from "../../../math/linalg/solve_linear_system.js";
 import { v3_dot } from "../../vec3/v3_dot.js";
 
 const MAX_FLOAT32 = 3.4028234663852886e+38;
-const SMALL_NUMBER = 1e-12;
-const VTK_MAX_WARNS = 3;
+
+const n12 = new Float64Array(3);
+const n13 = new Float64Array(3);
+const n14 = new Float64Array(3);
+
+const x12 = new Float64Array(3);
+const x13 = new Float64Array(3);
+const x14 = new Float64Array(3);
+
+const A = new Float64Array(9);
+
+const rhs = new Float64Array(3);
 
 /**
  * Compute the circumcenter (center[3]) and radius squared (method return value) of a tetrahedron defined by the four points x1, x2, x3, and x4.
@@ -21,23 +32,16 @@ export function tetrahedron_compute_circumsphere(
     points,
     a, b, c, d
 ) {
-    const n12 = [];
-    const n13 = [];
-    const n14 = [];
 
-    const x12 = [];
-    const x13 = [];
-    const x14 = [];
-
-    //  calculate normals and intersection points of bisecting planes.
+    // calculate normals and intersection points of bisecting planes.
     for (let i = 0; i < 3; i++) {
         const v_a = points[a * 3 + i];
-
         const v_b = points[b * 3 + i];
-        n12[i] = v_b - v_a;
         const v_c = points[c * 3 + i];
-        n13[i] = v_c - v_a;
         const v_d = points[d * 3 + i];
+
+        n12[i] = v_b - v_a;
+        n13[i] = v_c - v_a;
         n14[i] = v_d - v_a;
 
         x12[i] = (v_b + v_a) * 0.5;
@@ -45,28 +49,28 @@ export function tetrahedron_compute_circumsphere(
         x14[i] = (v_d + v_a) * 0.5;
     }
 
-    const A = [];
-
     array_copy(n12, 0, A, 0, 3);
     array_copy(n13, 0, A, 3, 3);
     array_copy(n14, 0, A, 6, 3);
 
-    const rhs = [];
-
     rhs[0] = v3_dot(n12[0], n12[1], n12[2], x12[0], x12[1], x12[2]);
     rhs[1] = v3_dot(n13[0], n13[1], n13[2], x13[0], x13[1], x13[2]);
     rhs[2] = v3_dot(n14[0], n14[1], n14[2], x14[0], x14[1], x14[2]);
 
     // Solve system of equations
     if (solve_linear_system(A, rhs, 3) === false) {
+
         // failed to solve, fall-back to infinitely-sized sphere centered around origin
         result[0] = result[1] = result[2] = 0;
         result[3] = MAX_FLOAT32;
         return;
+
     } else {
+
         result[0] = rhs[0];
         result[1] = rhs[1];
         result[2] = rhs[2];
+
     }
 
     let sum = 0;
@@ -77,10 +81,13 @@ export function tetrahedron_compute_circumsphere(
 
         diff = points[a * 3 + i] - rhs_offset;
         sum += diff * diff;
+
         diff = points[b * 3 + i] - rhs_offset;
         sum += diff * diff;
+
         diff = points[c * 3 + i] - rhs_offset;
         sum += diff * diff;
+
         diff = points[d * 3 + i] - rhs_offset;
         sum += diff * diff;
     }
@@ -95,175 +102,4 @@ export function tetrahedron_compute_circumsphere(
     }
 }
 
-/**
- * Solve linear equations Ax = b using Crout's method. Input is square matrix A
- * and load vector b. Solution x is written over load vector. The dimension of
- * the matrix is specified in size. If error is found, method returns a 0.
- *
- * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
- *
- * @param {number[]} A
- * @param {number[]} x
- * @param {number} size
- * @returns {boolean}
- */
-function solve_linear_system(A, x, size) {
-    const index = [];
-
-    if (luf_factor_linear_system(A, index, size) === 0) {
-        return false;
-    }
-
-    luf_solve_linear_system(A, index, x, size);
-
-    return true;
-}
-
-
-/**
- * Factor linear equations Ax = b using LU decomposition A = LU where L is
- * lower triangular matrix and U is upper triangular matrix. Input is
- * square matrix A, integer array of pivot indices index[0->n-1], and size
- * of square matrix n. Output factorization LU is in matrix A. If error is
- * found, method returns 0.
- * @param {number[]} A
- * @param {number[]} index
- * @param {number} size
- */
-function luf_factor_linear_system(A, index, size) {
-    const scale = [];
-
-    // double scratch[10];
-    // double* scale = (size < 10 ? scratch : new double[size]);
-    //
-    // int i, j, k;
-    // int maxI = 0;
-    // double largest, temp1, temp2, sum;
-    //
-    // // Manage number of output warnings
-    // static int numWarns = 0;
-    //
-    // //
-
-    let numWarns = 0;
-    let i, j, k;
-    let maxI = 0;
-    let largest, temp1, temp2, sum;
-    // Loop over rows to get implicit scaling information
-    //
-    for (i = 0; i < size; ++i) {
-        for (largest = 0.0, j = 0; j < size; ++j) {
-            if ((temp2 = Math.abs(A[i * size + j])) > largest) {
-                largest = temp2;
-            }
-        }
-
-        if (largest === 0.0 && numWarns++ < VTK_MAX_WARNS) {
-            // vtkGenericWarningMacro(<< "Unable to factor linear system");
-            return 0;
-        }
-        scale[i] = 1.0 / largest;
-    }
-    //
-    // Loop over all columns using Crout's method
-    //
-    for (j = 0; j < size; ++j) {
-        for (i = 0; i < j; ++i) {
-            sum = A[i * size + j];
-            for (k = 0; k < i; ++k) {
-                sum -= A[i * size + k] * A[k * size + j];
-            }
-            A[i * size + j] = sum;
-        }
-        //
-        // Begin search for largest pivot element
-        //
-        for (largest = 0.0, i = j; i < size; ++i) {
-            sum = A[i * size + j];
-            for (k = 0; k < j; ++k) {
-                sum -= A[i * size + k] * A[k * size + j];
-            }
-            A[i * size + j] = sum;
-
-            if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
-                largest = temp1;
-                maxI = i;
-            }
-        }
-        //
-        // Check for row interchange
-        //
-        if (j !== maxI) {
-            for (k = 0; k < size; ++k) {
-                temp1 = A[maxI * size + k];
-                A[maxI * size + k] = A[j * size + k];
-                A[j * size + k] = temp1;
-            }
-            scale[maxI] = scale[j];
-        }
-        //
-        // Divide by pivot element and perform elimination
-        //
-        index[j] = maxI;
 
-        if (Math.abs(A[j * size + j]) <= SMALL_NUMBER && numWarns++ < VTK_MAX_WARNS) {
-            //vtkGenericWarningMacro(<< "Unable to factor linear system");
-            return 0;
-        }
-
-        if (j !== (size - 1)) {
-            temp1 = 1.0 / A[j * size + j];
-            for (i = j + 1; i < size; ++i) {
-                A[i * size + j] *= temp1;
-            }
-        }
-    }
-
-    return 1;
-}
-
-/**
- * Solve linear equations Ax = b using LU decomposition A = LU where L is
- * lower triangular matrix and U is upper triangular matrix. Input is
- * factored matrix A=LU, integer array of pivot indices index[0->n-1],
- * load vector x[0->n-1], and size of square matrix n. Note that A=LU and
- * index[] are generated from method LUFactorLinearSystem). Also, solution
- * vector is written directly over input load vector.
- * @param {number[]} A
- * @param {number[]} index
- * @param {number[]} x
- * @param {number} size
- */
-function luf_solve_linear_system(A, index, x, size) {
-    let i, j, ii, idx;
-    let sum;
-    //
-    // Proceed with forward and backsubstitution for L and U
-    // matrices.  First, forward substitution.
-    //
-    for (ii = -1, i = 0; i < size; ++i) {
-        idx = index[i];
-        sum = x[idx];
-        x[idx] = x[i];
-
-        if (ii >= 0) {
-            for (j = ii; j <= (i - 1); ++j) {
-                sum -= A[i * size + j] * x[j];
-            }
-        } else if (sum !== 0.0) {
-            ii = i;
-        }
-
-        x[i] = sum;
-    }
-    //
-    // Now, back substitution
-    //
-    for (i = size - 1; i >= 0; i--) {
-        sum = x[i];
-        for (j = i + 1; j < size; ++j) {
-            sum -= A[i * size + j] * x[j];
-        }
-        x[i] = sum / A[i * size + i];
-    }
-}

package/src/core/geom/3d/tetrahedra/triangle/prototype.js

@@ -54,7 +54,7 @@ async function main() {
 
     transform.scale.setScalar(1.5);
 
-    scene.addMesh(
+    scene.createMesh(
         new BoxBufferGeometry(),
         new MeshStandardMaterial(),
         transform.matrix

package/src/core/geom/3d/tetrahedra/visualize_tetrahedral_mesh.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} positions
+ * @param {string|number} color CSS color definition
+ * @param {number} opacity
+ * @returns {Entity}
+ */
+export function visualize_tetrahedral_mesh({ mesh, positions, color, opacity }: TetrahedralMesh): Entity;
+import Entity from "../../../../engine/ecs/Entity.js";
+//# sourceMappingURL=visualize_tetrahedral_mesh.d.ts.map

package/src/core/geom/3d/tetrahedra/visualize_tetrahedral_mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visualize_tetrahedral_mesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/visualize_tetrahedral_mesh.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,kGAFa,MAAM,CA2BlB;mBAxCkB,kCAAkC"}

package/src/core/geom/3d/tetrahedra/visualize_tetrahedral_mesh.js

@@ -0,0 +1,42 @@
+import { LineBasicMaterial } from "three";
+import Entity from "../../../../engine/ecs/Entity.js";
+import { Transform } from "../../../../engine/ecs/transform/Transform.js";
+import { DrawMode } from "../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
+import { ShadedGeometry } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
+import { build_tetrahedral_mesh_buffer_geometry } from "./build_tetrahedral_mesh_buffer_geometry.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} positions
+ * @param {string|number} color CSS color definition
+ * @param {number} opacity
+ * @returns {Entity}
+ */
+export function visualize_tetrahedral_mesh({
+                                               mesh, positions,
+                                               color = '#FF00FF',
+                                               opacity = 0.35
+                                           }) {
+
+    const geometry = build_tetrahedral_mesh_buffer_geometry(mesh, positions);
+
+    const sg = ShadedGeometry.from(geometry, new LineBasicMaterial({
+        color: color,
+        transparent: true,
+        opacity,
+        depthWrite: false
+    }), DrawMode.LineSegments);
+
+    sg.clearFlag(ShadedGeometryFlags.CastShadow);
+    sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    const entity = new Entity();
+
+    entity
+        .add(sg)
+        .add(new Transform());
+
+    return entity;
+}

package/src/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -21,7 +21,7 @@ import { seededRandom } from "../../../../math/random/seededRandom.js";
 import { v3_dot } from "../../../vec3/v3_dot.js";
 import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
 import { SurfacePoint3 } from "../../SurfacePoint3.js";
-import { computeTriangleSurfaceArea } from "../../triangle/computeTriangleSurfaceArea.js";
+import { compute_triangle_area_3d } from "../../triangle/compute_triangle_area_3d.js";
 import { expandConnectivityByLocality } from "../expandConnectivityByLocality.js";
 import { TopoMesh } from "../struct/TopoMesh.js";
 import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
@@ -226,7 +226,7 @@ async function main(engine) {
                     filter(current, prev) {
                         current.computeNormal();
 
-                        const area = computeTriangleSurfaceArea(
+                        const area = compute_triangle_area_3d(
                             current.vertices[0].x,
                             current.vertices[0].z,
                             current.vertices[0].y,

package/src/core/geom/3d/topology/tm_face_area.js

@@ -1,4 +1,4 @@
-import { computeTriangleSurfaceArea } from "../triangle/computeTriangleSurfaceArea.js";
+import { compute_triangle_area_3d } from "../triangle/compute_triangle_area_3d.js";
 
 /**
  *
@@ -10,7 +10,7 @@ export function tm_face_area(face) {
     const v1 = face.vertices[1];
     const v2 = face.vertices[2];
 
-    return computeTriangleSurfaceArea(
+    return compute_triangle_area_3d(
         v0.x, v0.y, v0.z,
         v1.x, v1.y, v1.z,
         v2.x, v2.y, v2.z