@woosh/meep-engine 2.109.1 → 2.109.2

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Distance of the nearest point along the plane normal from the plane
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @param {number} _x0
+ * @param {number} _y0
+ * @param {number} _z0
+ * @param {number} _x1
+ * @param {number} _y1
+ * @param {number} _z1
+ * @returns {number}
+ */
+export function aabb3_compute_distance_above_plane_min(plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number, _x0: number, _y0: number, _z0: number, _x1: number, _y1: number, _z1: number): number;
+//# sourceMappingURL=aabb3_compute_distance_above_plane_min.d.ts.map

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_compute_distance_above_plane_min.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,uEAZW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAelB"}

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.js

@@ -0,0 +1,29 @@
+/**
+ * Distance of the nearest point along the plane normal from the plane
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @param {number} _x0
+ * @param {number} _y0
+ * @param {number} _z0
+ * @param {number} _x1
+ * @param {number} _y1
+ * @param {number} _z1
+ * @returns {number}
+ */
+export function aabb3_compute_distance_above_plane_min(
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    _x0, _y0, _z0,
+    _x1, _y1, _z1
+) {
+
+    // pick a corner point that is the closest along the plane normal
+    const px = plane_normal_x > 0 ? _x0 : _x1;
+    const py = plane_normal_y > 0 ? _y0 : _y1;
+    const pz = plane_normal_z > 0 ? _z0 : _z1;
+
+    // dot(v4,v4) inlined for speed
+    return plane_constant + plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz;
+}
+

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.d.ts

@@ -3,7 +3,7 @@
  * @param {AABB3} result
  * @param {number[]|ArrayLike<number>} input
  * @param {number} input_length
- * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 transformation matrix
  */
-export function aabb3_from_v3_array_transformed(result: AABB3, input: number[] | ArrayLike<number>, input_length: number, e: ArrayLike<number> | number[] | Float32Array): void;
+export function aabb3_from_v3_array_transformed(result: AABB3, input: number[] | ArrayLike<number>, input_length: number, matrix: ArrayLike<number> | number[] | Float32Array): void;
 //# sourceMappingURL=aabb3_from_v3_array_transformed.d.ts.map

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_from_v3_array_transformed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,sEAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,KACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QA8BjD"}
+{"version":3,"file":"aabb3_from_v3_array_transformed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,sEAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QA8BjD"}

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js

@@ -1,14 +1,14 @@
-import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
 
 /**
  *
  * @param {AABB3} result
  * @param {number[]|ArrayLike<number>} input
  * @param {number} input_length
- * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 transformation matrix
  */
-export function aabb3_from_v3_array_transformed(result, input, input_length, e) {
+export function aabb3_from_v3_array_transformed(result, input, input_length, matrix) {
     let x0 = Infinity;
     let y0 = Infinity;
     let z0 = Infinity;
@@ -22,9 +22,9 @@ export function aabb3_from_v3_array_transformed(result, input, input_length, e)
         const y = input[i + 1];
         const z = input[i + 2];
 
-        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
-        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
-        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+        const _x = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12];
+        const _y = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
+        const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
 
         x0 = min2(_x, x0);
         y0 = min2(_y, y0);

package/src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]} aabb
+ * @param {number} aabb_offset
+ * @param {number[]} ray
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ */
+export function aabb3_overlaps_ray_segment(aabb: number[], aabb_offset: number, ray: number[], min_distance: number, max_distance: number): boolean;
+//# sourceMappingURL=aabb3_overlaps_ray_segment.d.ts.map

package/src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_overlaps_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iDAPW,MAAM,EAAE,eACR,MAAM,OACN,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,OAAO,CAmDnB"}

package/src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.js

@@ -0,0 +1,61 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} aabb
+ * @param {number} aabb_offset
+ * @param {number[]} ray
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ */
+export function aabb3_overlaps_ray_segment(
+    aabb, aabb_offset, ray,
+    min_distance, max_distance
+) {
+
+    const dir_x = ray[3];
+    const dir_y = ray[4];
+    const dir_z = ray[5];
+
+    const plane_offset = v3_dot(
+        ray[0], ray[1], ray[2],
+        dir_x, dir_y, dir_z
+    );
+
+    let x0, y0, z0, x1, y1, z1;
+
+    if (dir_x > 0) {
+        x0 = aabb[0];
+        x1 = aabb[3];
+    } else {
+        x1 = aabb[0];
+        x0 = aabb[3];
+    }
+
+    if (dir_y > 0) {
+        y0 = aabb[1];
+        y1 = aabb[4];
+    } else {
+        y1 = aabb[1];
+        y0 = aabb[4];
+    }
+
+    if (dir_z > 0) {
+        z0 = aabb[2];
+        z1 = aabb[5];
+    } else {
+        z1 = aabb[2];
+        z0 = aabb[5];
+    }
+
+    const min = plane_offset + dir_x * x0 + dir_y * y0 + dir_z * z0;
+
+    if (min >= max_distance) {
+        return false;
+    }
+
+    const max = plane_offset + dir_x * x1 + dir_y * y1 + dir_z * z1;
+
+    return max > min_distance;
+}

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

@@ -21,8 +21,8 @@
  * @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: number[], m4: number[] | Float32Array | mat4, a0: number, a1: number, a2: number): void;
 //# sourceMappingURL=eulerAnglesFromMatrix.d.ts.map

package/src/core/geom/3d/eulerAnglesFromMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA6DhB"}
+{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}

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/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