@woosh/meep-engine 2.163.11 → 2.164.0

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

@@ -1,160 +1,7 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-import { assert } from "../../../assert.js";
+import { tri3_ray_intersection } from "./tri3_ray_intersection.js";
 
 /**
- * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
- * @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 {SurfacePoint3} 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} bx
- * @param {number} by
- * @param {number} bz
- * @param {number} cx
- * @param {number} cy
- * @param {number} cz
- * @returns {boolean}
+ * @deprecated Renamed to {@link tri3_ray_intersection}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeTriangleRayIntersection(
-    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.isFinite(ax, 'ax');
-    assert.isFinite(ay, 'ay');
-    assert.isFinite(az, 'az');
-
-    assert.isFinite(bx, 'bx');
-    assert.isFinite(by, 'by');
-    assert.isFinite(bz, 'bz');
-
-    assert.isFinite(cx, 'cx');
-    assert.isFinite(cy, 'cy');
-    assert.isFinite(cz, 'cz');
-
-
-    // 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;
-
-    // Compute triangle normal
-
-    // normal = edge1 x edge2
-    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
-    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
-    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
-
-    let DdN = v3_dot(direction_x, direction_y, direction_z, normal_x, normal_y, normal_z);
-    let sign = 1;
-
-    if (DdN === 0) {
-        // ray and the triangle normal are orthogonal, means that the ray can not pass penetrate triangle
-        return false;
-    } else if (DdN < 0) {
-        sign = -1;
-        DdN = -DdN;
-    }
-
-    // diff = origin - a
-    const diff_x = origin_x - ax;
-    const diff_y = origin_y - ay;
-    const diff_z = origin_z - az;
-
-    // edge3 = diff x edge2
-    const edge3_x = diff_y * edge2_z - diff_z * edge2_y;
-    const edge3_y = diff_z * edge2_x - diff_x * edge2_z;
-    const edge3_z = diff_x * edge2_y - diff_y * edge2_x;
-
-    // DdQxE2 = sign * ( direction . edge3)
-    const DdQxE2 = sign * v3_dot(direction_x, direction_y, direction_z, edge3_x, edge3_y, edge3_z);
-
-    if (DdQxE2 < 0) {
-        // b1 < 0, no intersection
-        return false;
-    }
-
-    const edge4_x = edge1_y * diff_z - edge1_z * diff_y;
-    const edge4_y = edge1_z * diff_x - edge1_x * diff_z;
-    const edge4_z = edge1_x * diff_y - edge1_y * diff_x;
-
-    const DdE1xQ = sign * v3_dot(direction_x, direction_y, direction_z, edge4_x, edge4_y, edge4_z);
-
-    if (DdE1xQ < 0) {
-        // b2 < 0, no intersection
-        return false;
-    }
-
-    if (DdQxE2 + DdE1xQ > DdN) {
-        // b1+b2 > 1, no intersection
-        return false;
-    }
-
-    // Line intersects triangle, check if ray does.
-    const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
-
-    if (QdN < 0) {
-        // t < 0, no intersection
-        return false;
-
-    }
-
-    // Ray intersects triangle.
-    const t = QdN / DdN;
-
-    result.normal.set(
-        normal_x,
-        normal_y,
-        normal_z
-    );
-
-    result.position.set(
-        direction_x * t + origin_x,
-        direction_y * t + origin_y,
-        direction_z * t + origin_z,
-    );
-
-    return true;
-}
-
+export const computeTriangleRayIntersection = tri3_ray_intersection;

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

@@ -1,25 +1,7 @@
 /**
- * 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}
+ * @deprecated Renamed to {@link tri3_ray_intersection_barycentric}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeTriangleRayIntersectionBarycentric(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): boolean;
+export const computeTriangleRayIntersectionBarycentric: typeof tri3_ray_intersection_barycentric;
+import { tri3_ray_intersection_barycentric } from "./tri3_ray_intersection_barycentric.js";
 //# sourceMappingURL=computeTriangleRayIntersectionBarycentric.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTriangleRayIntersectionBarycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kEAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAqEnB"}
+{"version":3,"file":"computeTriangleRayIntersectionBarycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iGAA2F;kDANzC,wCAAwC"}

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

@@ -1,96 +1,7 @@
-import { assert } from "../../../assert.js";
-import { computeTriangleRayIntersectionBarycentricEdge } from "./computeTriangleRayIntersectionBarycentricEdge.js";
+import { tri3_ray_intersection_barycentric } from "./tri3_ray_intersection_barycentric.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}
+ * @deprecated Renamed to {@link tri3_ray_intersection_barycentric}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-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.isFinite(ax, 'ax');
-    assert.isFinite(ay, 'ay');
-    assert.isFinite(az, 'az');
-
-    assert.isFinite(bx, 'bx');
-    assert.isFinite(by, 'by');
-    assert.isFinite(bz, 'bz');
-
-    assert.isFinite(cx, 'cx');
-    assert.isFinite(cy, 'cy');
-    assert.isFinite(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
-    );
-}
-
-
+export const computeTriangleRayIntersectionBarycentric = tri3_ray_intersection_barycentric;

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

@@ -1,26 +1,7 @@
 /**
- * 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}
+ * @deprecated Renamed to {@link tri3_ray_intersection_barycentric_edge}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeTriangleRayIntersectionBarycentricEdge(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ax: number, ay: number, az: number, edge1_x: number, edge1_y: number, edge1_z: number, edge2_x: number, edge2_y: number, edge2_z: number): boolean;
+export const computeTriangleRayIntersectionBarycentricEdge: typeof tri3_ray_intersection_barycentric_edge;
+import { tri3_ray_intersection_barycentric_edge } from "./tri3_ray_intersection_barycentric_edge.js";
 //# sourceMappingURL=computeTriangleRayIntersectionBarycentricEdge.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTriangleRayIntersectionBarycentricEdge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sEAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CAsElB"}
+{"version":3,"file":"computeTriangleRayIntersectionBarycentricEdge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0GAAoG;uDAN7C,6CAA6C"}

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

@@ -1,95 +1,7 @@
-import { v3_dot } from "../../vec3/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){
-        // ray is parallel to the plane of the triange, no intersection possible
-        return false;
-    }
-
-    if (det <= 0) {
-        // back-face culling
-        // return false;
-    }
-
-    const inv_det = 1 / det;
-
-    // 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)*inv_det;
-
-    if (u < 0 || u > 1) {
-        // 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)*inv_det;
-
-    if (v < 0 || u + v > 1) {
-        // out of bounds
-        return false;
-    }
-
-
-
-    // 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 ;
-    result[2] = v ;
-
-    return true;
-}
+import { tri3_ray_intersection_barycentric_edge } from "./tri3_ray_intersection_barycentric_edge.js";
+
+/**
+ * @deprecated Renamed to {@link tri3_ray_intersection_barycentric_edge}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const computeTriangleRayIntersectionBarycentricEdge = tri3_ray_intersection_barycentric_edge;

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.d.ts

@@ -1,16 +1,7 @@
 /**
- *
- * @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[]|ArrayLike<number>|Uint32Array} indices
- * @param {number} triangle_index
- * @param {number[]|Float32Array} positions
- * @return {boolean}
+ * @deprecated Renamed to {@link tri3_ray_intersection_indexed}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeTriangleRayIntersectionBarycentricGeometry(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, indices: number[] | ArrayLike<number> | Uint32Array, triangle_index: number, positions: number[] | Float32Array): boolean;
+export const computeTriangleRayIntersectionBarycentricGeometry: typeof tri3_ray_intersection_indexed;
+import { tri3_ray_intersection_indexed } from "./tri3_ray_intersection_indexed.js";
 //# sourceMappingURL=computeTriangleRayIntersectionBarycentricGeometry.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTriangleRayIntersectionBarycentricGeometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0EAZW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,WAAW,kBACtC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CAwClB"}
+{"version":3,"file":"computeTriangleRayIntersectionBarycentricGeometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qGAA+F;8CANjD,oCAAoC"}

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

@@ -1,55 +1,7 @@
-import { computeTriangleRayIntersectionBarycentric } from "./computeTriangleRayIntersectionBarycentric.js";
-
-/**
- *
- * @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[]|ArrayLike<number>|Uint32Array} indices
- * @param {number} triangle_index
- * @param {number[]|Float32Array} positions
- * @return {boolean}
- */
-export function computeTriangleRayIntersectionBarycentricGeometry(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    indices, triangle_index, positions
-) {
-    const index_offset = triangle_index * 3;
-
-    const a = indices[index_offset];
-    const b = indices[index_offset + 1];
-    const c = indices[index_offset + 2];
-
-
-    const a_address = a * 3;
-    const b_address = b * 3;
-    const c_address = c * 3;
-
-
-    const ax = positions[a_address];
-    const ay = positions[a_address + 1];
-    const az = positions[a_address + 2];
-
-    const bx = positions[b_address];
-    const by = positions[b_address + 1];
-    const bz = positions[b_address + 2];
-
-    const cx = positions[c_address];
-    const cy = positions[c_address + 1];
-    const cz = positions[c_address + 2];
-
-    return computeTriangleRayIntersectionBarycentric(
-        result,
-        origin_x, origin_y, origin_z,
-        direction_x, direction_y, direction_z,
-        ax, ay, az,
-        bx, by, bz,
-        cx, cy, cz
-    );
-}
+import { tri3_ray_intersection_indexed } from "./tri3_ray_intersection_indexed.js";
+
+/**
+ * @deprecated Renamed to {@link tri3_ray_intersection_indexed}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const computeTriangleRayIntersectionBarycentricGeometry = tri3_ray_intersection_indexed;

package/src/core/geom/3d/triangle/compute_triangle_area_3d.d.ts

@@ -1,15 +1,7 @@
 /**
- * Based on: https://gamedev.stackexchange.com/questions/165643/how-to-calculate-the-surface-area-of-a-mesh
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @returns {number}
+ * @deprecated Renamed to {@link tri3_area}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_triangle_area_3d(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+export const compute_triangle_area_3d: typeof tri3_area;
+import { tri3_area } from "./tri3_area.js";
 //# sourceMappingURL=compute_triangle_area_3d.d.ts.map

package/src/core/geom/3d/triangle/compute_triangle_area_3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_triangle_area_3d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/compute_triangle_area_3d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,6CAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAoClB"}
+{"version":3,"file":"compute_triangle_area_3d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/compute_triangle_area_3d.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wDAAkD;0BANxB,gBAAgB"}

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

@@ -1,50 +1,7 @@
-import { assert } from "../../../assert.js";
-
-/**
- * Based on: https://gamedev.stackexchange.com/questions/165643/how-to-calculate-the-surface-area-of-a-mesh
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @returns {number}
- */
-export function compute_triangle_area_3d(
-    x0, y0, z0,
-    x1, y1, z1,
-    x2, y2, z2
-) {
-    assert.isNumber(x0,'x0');
-    assert.isNumber(y0, 'y0');
-    assert.isNumber(z0, 'z0');
-
-    assert.isNumber(x1, 'x1');
-    assert.isNumber(y1, 'y1');
-    assert.isNumber(z1, 'z1');
-
-    assert.isNumber(x2, 'x2');
-    assert.isNumber(y2, 'y2');
-    assert.isNumber(z2, 'z2');
-
-    const ax = x1 - x0;
-    const ay = y1 - y0;
-    const az = z1 - z0;
-
-    const bx = x2 - x0;
-    const by = y2 - y0;
-    const bz = z2 - z0;
-
-    //compute cross product
-    const x = ay * bz - az * by;
-    const y = az * bx - ax * bz;
-    const z = ax * by - ay * bx;
-
-    //area is equal to half-magnitude of the cross-product
-    const magnitude = Math.sqrt(x * x + y * y + z * z);
-
-    return magnitude * 0.5;
-}
+import { tri3_area } from "./tri3_area.js";
+
+/**
+ * @deprecated Renamed to {@link tri3_area}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const compute_triangle_area_3d = tri3_area;

package/src/core/geom/3d/triangle/compute_triangle_normal.d.ts

@@ -1,21 +1,7 @@
 /**
- *
- * @param {number[]|vec3|Float32Array|Float64Array} result
- * @param {number[]|vec3|Float32Array|Float64Array|{0:number, 1:number, 2:number}} vA
- * @param {number[]|vec3|Float32Array|Float64Array|{0:number, 1:number, 2:number}} vB
- * @param {number[]|vec3|Float32Array|Float64Array|{0:number, 1:number, 2:number}} vC
+ * @deprecated Renamed to {@link tri3_compute_normal_v3_objects}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_triangle_normal(result: number[] | vec3 | Float32Array | Float64Array, vA: number[] | vec3 | Float32Array | Float64Array | {
-    0: number;
-    1: number;
-    2: number;
-}, vB: number[] | vec3 | Float32Array | Float64Array | {
-    0: number;
-    1: number;
-    2: number;
-}, vC: number[] | vec3 | Float32Array | Float64Array | {
-    0: number;
-    1: number;
-    2: number;
-}): void;
+export const compute_triangle_normal: typeof tri3_compute_normal_v3_objects;
+import { tri3_compute_normal_v3_objects } from "./tri3_compute_normal_v3_objects.js";
 //# sourceMappingURL=compute_triangle_normal.d.ts.map

package/src/core/geom/3d/triangle/compute_triangle_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,gDALW,MAAM,EAAE,UAAM,YAAY,GAAC,YAAY,MACvC,MAAM,EAAE,UAAM,YAAY,GAAC,YAAY,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,MACtE,MAAM,EAAE,UAAM,YAAY,GAAC,YAAY,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,MACtE,MAAM,EAAE,UAAM,YAAY,GAAC,YAAY,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAiBhF"}
+{"version":3,"file":"compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,4EAAsE;+CANvB,qCAAqC"}