@woosh/meep-engine 2.163.10 → 2.164.0

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

@@ -0,0 +1,167 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} result result is written as a 2d vector, since barycentrics add up to 1, we omit the last value
+ * @param {number} result_offset
+ * @param {number} px reference point
+ * @param {number} py reference point
+ * @param {number} pz reference point
+ * @param {number} ax Triangle apex A
+ * @param {number} ay Triangle apex A
+ * @param {number} az Triangle apex A
+ * @param {number} bx Triangle apex B
+ * @param {number} by Triangle apex B
+ * @param {number} bz Triangle apex B
+ * @param {number} cx Triangle apex C
+ * @param {number} cy Triangle apex C
+ * @param {number} cz Triangle apex C
+ * @returns {void}
+ */
+export function tri3_closest_point_barycentric(
+    result, result_offset,
+    px, py, pz,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    // adapted from https://github.com/mrdoob/three.js/blob/676e85dc7cd5971a6565c4152e9e6d8bdd20a2b7/src/math/Triangle.js#L222
+
+    let v, w;
+
+    // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
+    // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
+    // under the accompanying license; see chapter 5.1.5 for detailed explanation.
+    // basically, we're distinguishing which of the voronoi regions of the triangle
+    // the point lies in with the minimum amount of redundant computation.
+
+    // localize coordinates with respect to A
+    const _vab_x = bx - ax;
+    const _vab_y = by - ay;
+    const _vab_z = bz - az;
+
+    const _vac_x = cx - ax;
+    const _vac_y = cy - ay;
+    const _vac_z = cz - az;
+
+    const _vap_x = px - ax;
+    const _vap_y = py - ay;
+    const _vap_z = pz - az;
+
+    const d1 = v3_dot(_vab_x, _vab_y, _vab_z, _vap_x, _vap_y, _vap_z);
+    const d2 = v3_dot(_vac_x, _vac_y, _vac_z, _vap_x, _vap_y, _vap_z);
+
+    if (d1 <= 0 && d2 <= 0) {
+
+        // vertex region of A; barycentric coords (1, 0, 0)
+
+        result[result_offset] = 1;
+        result[result_offset + 1] = 0;
+
+        return;
+
+    }
+
+    const _vbp_x = px - bx;
+    const _vbp_y = py - by;
+    const _vbp_z = pz - bz;
+
+    const d3 = v3_dot(_vab_x, _vab_y, _vab_z, _vbp_x, _vbp_y, _vbp_z);
+    const d4 = v3_dot(_vac_x, _vac_y, _vac_z, _vbp_x, _vbp_y, _vbp_z);
+
+    if (d3 >= 0 && d4 <= d3) {
+
+        // vertex region of B; barycentric coords (0, 1, 0)
+
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+
+        return;
+
+    }
+
+    const vc = d1 * d4 - d3 * d2;
+    if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+
+        const s = d1 - d3;
+
+        if (s !== 0) {
+            v = d1 / s;
+        } else {
+            v = 0;
+        }
+        // edge region of AB; barycentric coords (1-v, v, 0)
+
+        result[result_offset] = 1 - v;
+        result[result_offset + 1] = v;
+
+        return;
+
+    }
+
+    const _vcp_x = px - cx;
+    const _vcp_y = py - cy;
+    const _vcp_z = pz - cz;
+
+    const d5 = v3_dot(_vab_x, _vab_y, _vab_z, _vcp_x, _vcp_y, _vcp_z);
+    const d6 = v3_dot(_vac_x, _vac_y, _vac_z, _vcp_x, _vcp_y, _vcp_z);
+
+    if (d6 >= 0 && d5 <= d6) {
+
+        // vertex region of C; barycentric coords (0, 0, 1)
+
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+
+        return;
+
+    }
+
+    const vb = d5 * d2 - d1 * d6;
+    if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+
+        const s = d2 - d6;
+
+        if (s !== 0) {
+            w = d2 / s;
+        } else {
+            w = 0;
+        }
+
+        // edge region of AC; barycentric coords (1-w, 0, w)
+
+        result[result_offset] = 1 - w;
+        result[result_offset + 1] = 0;
+
+        return;
+
+    }
+
+    const va = d3 * d6 - d5 * d4;
+    if (va <= 0 && (d4 - d3) >= 0 && (d5 - d6) >= 0) {
+
+        const s = (d4 - d3) + (d5 - d6);
+
+        if(s !== 0) {
+            w = (d4 - d3) / s;
+        }else{
+            w = 1;
+        }
+
+        // edge region of BC; barycentric coords (0, 1-w, w)
+
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1 - w;
+
+        return;
+
+    }
+
+    // face region
+    const denom = 1 / (va + vb + vc);
+    const u = va * denom
+    v = vb * denom;
+
+    result[result_offset] = u;
+    result[result_offset + 1] = v;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Compute face normal for a triangle
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
+ * @param {number} result_offset offset into result array where to start writing
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} c_x
+ * @param {number} c_y
+ * @param {number} c_z
+ */
+export function tri3_compute_normal(result: number[] | Float32Array | Float64Array, result_offset: number, a_x: number, a_y: number, a_z: number, b_x: number, b_y: number, b_z: number, c_x: number, c_y: number, c_z: number): void;
+//# sourceMappingURL=tri3_compute_normal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,4CAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}

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

@@ -0,0 +1,57 @@
+import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
+
+/**
+ * Compute face normal for a triangle
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
+ * @param {number} result_offset offset into result array where to start writing
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} c_x
+ * @param {number} c_y
+ * @param {number} c_z
+ */
+export function tri3_compute_normal(
+    result, result_offset,
+    a_x, a_y, a_z,
+    b_x, b_y, b_z,
+    c_x, c_y, c_z
+) {
+
+    //compute CB and AB vectors
+    const vCBx = c_x - b_x;
+    const vCBy = c_y - b_y;
+    const vCBz = c_z - b_z;
+
+    const vABx = a_x - b_x;
+    const vABy = a_y - b_y;
+    const vABz = a_z - b_z;
+
+    //compute triangle normal
+    const crossX = vCBy * vABz - vCBz * vABy;
+    const crossY = vCBz * vABx - vCBx * vABz;
+    const crossZ = vCBx * vABy - vCBy * vABx;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    if (l_sqr === 0) {
+        // degenerate triangle, provide arbitrary invalid result
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+        result[result_offset + 2] = 0;
+        return;
+    }
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}

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

@@ -0,0 +1,21 @@
+/**
+ *
+ * @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
+ */
+export function tri3_compute_normal_v3_objects(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;
+//# sourceMappingURL=tri3_compute_normal_v3_objects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_compute_normal_v3_objects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_normal_v3_objects.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,uDALW,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"}

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

@@ -0,0 +1,25 @@
+import { tri3_compute_normal } from "./tri3_compute_normal.js";
+
+/**
+ *
+ * @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
+ */
+export function tri3_compute_normal_v3_objects(result, vA, vB, vC) {
+
+    const vAx = vA[0];
+    const vAy = vA[1];
+    const vAz = vA[2];
+
+    const vBx = vB[0];
+    const vBy = vB[1];
+    const vBz = vB[2];
+
+    const vCx = vC[0];
+    const vCy = vC[1];
+    const vCz = vC[2];
+
+    tri3_compute_normal(result, 0, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz);
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Produces a numeric result to indicate which side of the plane the triangle is on
+ * between +3 and -3:
+ *      +3 means that all vertices ave above the plane
+ *      -3 means all vertices are below the plane
+ *      values in between indicate that the plane cuts through the triangle
+ *
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @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 {number}
+ */
+export function tri3_compute_plane_side(plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+//# sourceMappingURL=tri3_compute_plane_side.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_plane_side.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wDAfW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB"}

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

@@ -0,0 +1,39 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ * Produces a numeric result to indicate which side of the plane the triangle is on
+ * between +3 and -3:
+ *      +3 means that all vertices ave above the plane
+ *      -3 means all vertices are below the plane
+ *      values in between indicate that the plane cuts through the triangle
+ *
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @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 {number}
+ */
+export function tri3_compute_plane_side(
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    let result = 0;
+
+    // compute side for each point
+    result += ( v3_dot(plane_normal_x, plane_normal_y, plane_normal_z, ax, ay, az) + plane_constant ) >= 0 ? 1 : -1;
+    result += ( v3_dot(plane_normal_x, plane_normal_y, plane_normal_z, bx, by, bz) + plane_constant ) >= 0 ? 1 : -1;
+    result += ( v3_dot(plane_normal_x, plane_normal_y, plane_normal_z, cx, cy, cz) + plane_constant ) >= 0 ? 1 : -1;
+
+    return result;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Compute signed volume of a tetrahedron with the last point at the origin
+ * Triangle is defined by points A,B,C
+ * @see "EFFICIENT FEATURE EXTRACTION FOR 2D/3D OBJECTS IN MESH REPRESENTATION" by Cha Zhang and Tsuhan Chen
+ * @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
+ * @return {number}
+ */
+export function tri3_compute_signed_volume(ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+//# sourceMappingURL=tri3_compute_signed_volume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,+CAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAiBjB"}

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

@@ -0,0 +1,33 @@
+const ONE_OVER_SIX = 1.0 / 6.0;
+
+/**
+ * Compute signed volume of a tetrahedron with the last point at the origin
+ * Triangle is defined by points A,B,C
+ * @see "EFFICIENT FEATURE EXTRACTION FOR 2D/3D OBJECTS IN MESH REPRESENTATION" by Cha Zhang and Tsuhan Chen
+ * @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
+ * @return {number}
+ */
+export function tri3_compute_signed_volume(
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    const v321 = cx * by * az;
+    const v231 = bx * cy * az;
+    const v312 = cx * ay * bz;
+    const v132 = ax * cy * bz;
+    const v213 = bx * ay * cz;
+    const v123 = ax * by * cz;
+
+    return ONE_OVER_SIX * (-v321 + v231 + v312 - v132 - v213 + v123);
+
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Calculates the incenter of a triangle.
+ *
+ * @see https://en.wikipedia.org/wiki/Incenter
+ * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
+ * @param {number} output_offset
+ * @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 {boolean} true when the result was calculated, false for degenerate triangle
+ */
+export function tri3_incenter(output: number[] | Float32Array | Float64Array | ArrayLike<number>, output_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): boolean;
+//# sourceMappingURL=tri3_incenter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_incenter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_incenter.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,sCAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,MAAM,CAAC,iBACpD,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CA4CnB"}

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

@@ -0,0 +1,60 @@
+/**
+ * Calculates the incenter of a triangle.
+ *
+ * @see https://en.wikipedia.org/wiki/Incenter
+ * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
+ * @param {number} output_offset
+ * @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 {boolean} true when the result was calculated, false for degenerate triangle
+ */
+export function tri3_incenter(
+    output, output_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    x2, y2, z2
+) {
+    // Calculate edge lengths opposite to each vertex
+
+    // 'a' is length of edge v1-v2 (opposite v0)
+    const dxA = x2 - x1;
+    const dyA = y2 - y1;
+    const dzA = z2 - z1;
+
+    const a = Math.sqrt(dxA * dxA + dyA * dyA + dzA * dzA);
+
+    // 'b' is length of edge v2-v0 (opposite v1)
+    const dxB = x0 - x2;
+    const dyB = y0 - y2;
+    const dzB = z0 - z2;
+
+    const b = Math.sqrt(dxB * dxB + dyB * dyB + dzB * dzB);
+
+    // 'c' is length of edge v0-v1 (opposite v2)
+    const dxC = x1 - x0;
+    const dyC = y1 - y0;
+    const dzC = z1 - z0;
+
+    const c = Math.sqrt(dxC * dxC + dyC * dyC + dzC * dzC);
+
+    const perimeter = a + b + c;
+
+    if (perimeter <= 0) {
+        // 0 perimeter triangle
+        return false;
+    }
+
+    output[output_offset] = (a * x0 + b * x1 + c * x2) / perimeter;
+    output[output_offset + 1] = (a * y0 + b * y1 + c * y2) / perimeter;
+    output[output_offset + 2] = (a * z0 + b * z1 + c * z2) / perimeter;
+
+    return true;
+
+}

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

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @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 tri3_intersects_clipping_volume(planes: number[] | Float32Array, planes_offset: number, plane_count: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): boolean;
+//# sourceMappingURL=tri3_intersects_clipping_volume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_intersects_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_intersects_clipping_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wDAdW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmCnB"}

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

@@ -0,0 +1,51 @@
+import { tri3_compute_plane_side } from "./tri3_compute_plane_side.js";
+
+/**
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @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 tri3_intersects_clipping_volume(
+    planes, planes_offset, plane_count,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    for (let j = 0; j < plane_count; j++) {
+
+        const plane_address = planes_offset + j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = tri3_compute_plane_side(
+            plane_normal_x,
+            plane_normal_y,
+            plane_normal_z,
+            plane_constant,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        if (side === -3) {
+            // fully outside
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function tri3_mesh_compute_signed_volume(positions: ArrayLike<number>, indices: ArrayLike<number>): number;
+//# sourceMappingURL=tri3_mesh_compute_signed_volume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_mesh_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,2DALW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,MAAM,CAoBlB"}

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

@@ -0,0 +1,38 @@
+import { tri3_compute_signed_volume } from "./tri3_compute_signed_volume.js";
+
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function tri3_mesh_compute_signed_volume(positions, indices) {
+    let total = 0;
+
+    const n = indices.length;
+    for (let i = 0; i < n; i += 3) {
+        const a3 = indices[i] * 3;
+        const b3 = indices[i + 1] * 3;
+        const c3 = indices[i + 2] * 3;
+
+        total += tri3_compute_signed_volume(
+            positions[a3],     positions[a3 + 1], positions[a3 + 2],
+            positions[b3],     positions[b3 + 1], positions[b3 + 2],
+            positions[c3],     positions[c3 + 1], positions[c3 + 2],
+        );
+    }
+
+    return total;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * 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}
+ */
+export function tri3_ray_intersection(result: SurfacePoint3, 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;
+//# sourceMappingURL=tri3_ray_intersection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_ray_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uEAjBW,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,CAwInB"}