@woosh/meep-engine 2.48.22 → 2.49.0

package/src/core/geom/3d/tetrahedra/delaunay/{debug_validate_mesh.js → debug/debug_validate_mesh.js}

@@ -1,4 +1,4 @@
-import { validate_tetrahedral_mesh } from "../validate_tetrahedral_mesh.js";
+import { validate_tetrahedral_mesh } from "../../validate_tetrahedral_mesh.js";
 
 /**
  *

package/src/core/geom/3d/tetrahedra/delaunay/{push_boundary_with_validation.js → debug/push_boundary_with_validation.js}

@@ -1,4 +1,4 @@
-import { tetrahedron_compute_signed_volume } from "../tetrahedron_compute_signed_volume.js";
+import { tetrahedron_compute_signed_volume } from "../../tetrahedron_compute_signed_volume.js";
 
 /**
  * Debug method that validates cavity tet before pushing it

package/src/core/geom/3d/tetrahedra/delaunay/{validate_cavity_boundary.js → debug/validate_cavity_boundary.js}

@@ -1,5 +1,5 @@
-import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
-import { array_range_equal_strict } from "../../../../collection/array/array_range_equal_strict.js";
+import { INVALID_NEIGHBOUR } from "../../TetrahedralMesh.js";
+import { array_range_equal_strict } from "../../../../../collection/array/array_range_equal_strict.js";
 
 export function debug_validate_cavity_boundary(mesh, cavity) {
     let valid = true;

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_cavity.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../assert.js";
 import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
-import { in_sphere_robust } from "../in_sphere_robust.js";
+import { in_sphere3d_robust } from "../../sphere/in_sphere3d_robust.js";
 
 /**
  *
@@ -56,7 +56,7 @@ export function tetrahedral_mesh_compute_cavity(
                 continue;
             }
 
-            if (in_sphere_robust(
+            if (in_sphere3d_robust(
                 points,
                 mesh.getVertexIndex(neighbour_index, 0),
                 mesh.getVertexIndex(neighbour_index, 1),

package/src/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -158,167 +158,3 @@ export function computeTriangleRayIntersection(
     return true;
 }
 
-/**
- * Compute barycentric coordinates for triangle intersection
- * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
- * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
- * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
- * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} edge1_x
- * @param {number} edge1_y
- * @param {number} edge1_z
- * @param {number} edge2_x
- * @param {number} edge2_y
- * @param {number} edge2_z
- * @return {boolean}
- */
-export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z) {
-    // begin calculating determinant - also used to calculate U parameter
-
-    // CROSS(pvec, dir, edge2)
-    const pvec_x = direction_y * edge2_z - direction_z * edge2_y;
-    const pvec_y = direction_z * edge2_x - direction_x * edge2_z;
-    const pvec_z = direction_x * edge2_y - direction_y * edge2_x;
-
-    //if determinant is near zero, ray lies in plane of triangle
-    const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
-
-    if (det <= 0) {
-        // back-face culling
-        return false;
-    }
-
-    // calculate distance from vert0 to ray origin (not really, but okay)
-    const tvec_x = origin_x - ax;
-    const tvec_y = origin_y - ay;
-    const tvec_z = origin_z - az;
-
-    // calculate u
-    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
-
-    if (u < 0 || u > det) {
-        // outside of bounds of the triangle
-        return false;
-    }
-
-    // prepare to test V parameter
-    // CROSS(qvec, tvec, edge1)
-    const qvec_x = tvec_y * edge1_z - tvec_z * edge1_y;
-    const qvec_y = tvec_z * edge1_x - tvec_x * edge1_z;
-    const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
-
-    // calculate V parameter
-    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
-
-    if (v < 0 || u + v > det) {
-        // out of bounds
-        return false;
-    }
-
-
-    const inv_det = 1 / det;
-
-    // calculate t, scale parameter, ray intersects triangle
-    const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
-
-    result[0] = t;
-    result[1] = u*inv_det;
-    result[2] = v*inv_det;
-
-    return true;
-}
-
-/**
- * Compute barycentric coordinates for triangle intersection
- * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
- * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
- * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} bx
- * @param {number} by
- * @param {number} bz
- * @param {number} cx
- * @param {number} cy
- * @param {number} cz
- * @returns {boolean}
- */
-export function computeTriangleRayIntersectionBarycentric(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    ax, ay, az,
-    bx, by, bz,
-    cx, cy, cz
-) {
-    assert.isNumber(ax, 'ax');
-    assert.isNumber(ay, 'ay');
-    assert.isNumber(az, 'az');
-
-    assert.isNumber(bx, 'bx');
-    assert.isNumber(by, 'by');
-    assert.isNumber(bz, 'bz');
-
-    assert.isNumber(cx, 'cx');
-    assert.isNumber(cy, 'cy');
-    assert.isNumber(cz, 'cz');
-
-    // nan checks
-    assert.notNaN(ax, 'ax');
-    assert.notNaN(ay, 'ay');
-    assert.notNaN(az, 'az');
-
-    assert.notNaN(bx, 'bx');
-    assert.notNaN(by, 'by');
-    assert.notNaN(bz, 'bz');
-
-    assert.notNaN(cx, 'cx');
-    assert.notNaN(cy, 'cy');
-    assert.notNaN(cz, 'cz');
-
-    // finate number check
-    assert.isFiniteNumber(ax, 'ax');
-    assert.isFiniteNumber(ay, 'ay');
-    assert.isFiniteNumber(az, 'az');
-
-    assert.isFiniteNumber(bx, 'bx');
-    assert.isFiniteNumber(by, 'by');
-    assert.isFiniteNumber(bz, 'bz');
-
-    assert.isFiniteNumber(cx, 'cx');
-    assert.isFiniteNumber(cy, 'cy');
-    assert.isFiniteNumber(cz, 'cz');
-
-
-    // find vectors for two edges sharing vert
-
-    // edge1 = a - b
-    const edge1_x = bx - ax;
-    const edge1_y = by - ay;
-    const edge1_z = bz - az;
-
-    // edge2 = c - a
-    const edge2_x = cx - ax;
-    const edge2_y = cy - ay;
-    const edge2_z = cz - az;
-
-    return computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z);
-}

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js

@@ -0,0 +1,87 @@
+import { assert } from "../../../assert.js";
+import { computeTriangleRayIntersectionBarycentricEdge } from "./computeTriangleRayIntersectionBarycentricEdge.js";
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentric(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFiniteNumber(ax, 'ax');
+    assert.isFiniteNumber(ay, 'ay');
+    assert.isFiniteNumber(az, 'az');
+
+    assert.isFiniteNumber(bx, 'bx');
+    assert.isFiniteNumber(by, 'by');
+    assert.isFiniteNumber(bz, 'bz');
+
+    assert.isFiniteNumber(cx, 'cx');
+    assert.isFiniteNumber(cy, 'cy');
+    assert.isFiniteNumber(cz, 'cz');
+
+
+    // find vectors for two edges sharing vert
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    return computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z);
+}

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js

@@ -0,0 +1,81 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} edge1_x
+ * @param {number} edge1_y
+ * @param {number} edge1_z
+ * @param {number} edge2_x
+ * @param {number} edge2_y
+ * @param {number} edge2_z
+ * @return {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z) {
+    // begin calculating determinant - also used to calculate U parameter
+
+    // CROSS(pvec, dir, edge2)
+    const pvec_x = direction_y * edge2_z - direction_z * edge2_y;
+    const pvec_y = direction_z * edge2_x - direction_x * edge2_z;
+    const pvec_z = direction_x * edge2_y - direction_y * edge2_x;
+
+    //if determinant is near zero, ray lies in plane of triangle
+    const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
+
+    if (det <= 0) {
+        // back-face culling
+        return false;
+    }
+
+    // calculate distance from vert0 to ray origin (not really, but okay)
+    const tvec_x = origin_x - ax;
+    const tvec_y = origin_y - ay;
+    const tvec_z = origin_z - az;
+
+    // calculate u
+    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
+
+    if (u < 0 || u > det) {
+        // outside of bounds of the triangle
+        return false;
+    }
+
+    // prepare to test V parameter
+    // CROSS(qvec, tvec, edge1)
+    const qvec_x = tvec_y * edge1_z - tvec_z * edge1_y;
+    const qvec_y = tvec_z * edge1_x - tvec_x * edge1_z;
+    const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
+
+    // calculate V parameter
+    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
+
+    if (v < 0 || u + v > det) {
+        // out of bounds
+        return false;
+    }
+
+
+    const inv_det = 1 / det;
+
+    // calculate t, scale parameter, ray intersects triangle
+    const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
+
+    result[0] = t;
+    result[1] = u * inv_det;
+    result[2] = v * inv_det;
+
+    return true;
+}

package/src/core/geom/{GeometryMath.js → 3d/triangle/rayTriangleIntersection.js}

@@ -1,5 +1,5 @@
-import { SurfacePoint3 } from "./3d/SurfacePoint3.js";
-import { computeTriangleRayIntersection } from "./3d/triangle/computeTriangleRayIntersection.js";
+import { SurfacePoint3 } from "../SurfacePoint3.js";
+import { computeTriangleRayIntersection } from "./computeTriangleRayIntersection.js";
 
 
 const sp3 = new SurfacePoint3();
@@ -15,7 +15,11 @@ const sp3 = new SurfacePoint3();
  * @param {Vector3} c
  * @returns {boolean}
  */
-export function rayTriangleIntersection(result, rayOrigin, rayDirection, a, b, c) {
+export function rayTriangleIntersection(
+    result,
+    rayOrigin, rayDirection,
+    a, b, c
+) {
 
     const hit_found = computeTriangleRayIntersection(
         sp3,