@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -0,0 +1,19 @@
+/**
+ * Band `l`'s attenuation under convolution with a von Mises-Fisher lobe of concentration `kappa`:
+ * `exp(-l(l+1) / (2 kappa))`.
+ *
+ * The large-kappa form of the vMF's zonal coefficients, which is what Ref-NeRF's integrated
+ * directional encoding uses (Verbin et al., "Ref-NeRF", CVPR 2022 — [VHM*22]) and what
+ * Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai use to encode roughness continuously in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219), with `kappa = 1 / alpha`. Band 0 is never attenuated.
+ *
+ * WGSL twin: `sh_vmf_window` (`shader/chunk/spherical_harmonics/chunk_sh_vmf_window.js`).
+ *
+ * @param {number} l band
+ * @param {number} kappa concentration, > 0; larger is sharper
+ * @returns {number} in (0, 1]
+ */
+export function sh_vmf_window(l, kappa) {
+    return Math.exp(-l * (l + 1) / (2 * kappa));
+}

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

@@ -0,0 +1,49 @@
+/**
+ * How a triangle of a surface meets its neighbours, as bits: across each of its three edges, and at
+ * each of its three corners.
+ *
+ * Edge `k` of triangle `(A, B, C)` runs from its vertex `k` to its vertex `k + 1`: edge 0 is A→B,
+ * edge 1 is B→C, edge 2 is C→A. Each edge carries at most one class:
+ *
+ * - FLAT: the neighbour's plane is within {@link FLAT_EDGE_COS } of this triangle's — the two are, for
+ *   collision, one plane, and the edge between them is an artefact of triangulation, not a feature of
+ *   the surface.
+ * - CONCAVE: the neighbour bends up, toward the outside (a valley, the corner of a floor and a wall).
+ * - neither: CONVEX — the neighbour bends away (a ridge), or there is no single neighbour (the rim of
+ *   an open surface, an edge three or more triangles share). A real edge.
+ *
+ * A corner is FLAT when every edge of the surface that meets there is: the vertex is an artefact of
+ * triangulation too. Any real edge meeting there — a ridge, the rim — makes it a real vertex, even
+ * where both of this triangle's own edges at it are flat (the triangle beside a ridge that touches
+ * the crest at one corner).
+ *
+ * Shifting edge 0's bit (or vertex A's) left by `k` gives edge `k`'s (vertex `k`'s).
+ *
+ * The edge classes are Box3D's `b3MeshEdgeFlags` (types.h), which spell FLAT as "concave from both
+ * sides"; the corner class is this engine's.
+ */
+export type TriangleEdgeFlags = number;
+export namespace TriangleEdgeFlags {
+    let None: number;
+    let FlatAB: number;
+    let FlatBC: number;
+    let FlatCA: number;
+    let ConcaveAB: number;
+    let ConcaveBC: number;
+    let ConcaveCA: number;
+    let FlatVertexA: number;
+    let FlatVertexB: number;
+    let FlatVertexC: number;
+}
+/**
+ * The edge bits of a {@link TriangleEdgeFlags} word, FLAT and CONCAVE.
+ * @type {number}
+ */
+export const TRIANGLE_EDGE_BITS: number;
+/**
+ * Cosine of the largest angle between two triangles' normals at which the edge they share still
+ * counts as FLAT: 5°, Box3D's `cos5Deg` (mesh.c, `b3IdentifyEdges`).
+ * @type {number}
+ */
+export const FLAT_EDGE_COS: number;
+//# sourceMappingURL=TriangleEdgeFlags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TriangleEdgeFlags.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/TriangleEdgeFlags.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;gCAyBU,MAAM;;;;;;;;;;;;;AAkBhB;;;GAGG;AACH,iCAFU,MAAM,CAEqB;AAErC;;;;GAIG;AACH,4BAFU,MAAM,CAEoB"}

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

@@ -0,0 +1,55 @@
+/**
+ * How a triangle of a surface meets its neighbours, as bits: across each of its three edges, and at
+ * each of its three corners.
+ *
+ * Edge `k` of triangle `(A, B, C)` runs from its vertex `k` to its vertex `k + 1`: edge 0 is A→B,
+ * edge 1 is B→C, edge 2 is C→A. Each edge carries at most one class:
+ *
+ * - FLAT: the neighbour's plane is within {@link FLAT_EDGE_COS} of this triangle's — the two are, for
+ *   collision, one plane, and the edge between them is an artefact of triangulation, not a feature of
+ *   the surface.
+ * - CONCAVE: the neighbour bends up, toward the outside (a valley, the corner of a floor and a wall).
+ * - neither: CONVEX — the neighbour bends away (a ridge), or there is no single neighbour (the rim of
+ *   an open surface, an edge three or more triangles share). A real edge.
+ *
+ * A corner is FLAT when every edge of the surface that meets there is: the vertex is an artefact of
+ * triangulation too. Any real edge meeting there — a ridge, the rim — makes it a real vertex, even
+ * where both of this triangle's own edges at it are flat (the triangle beside a ridge that touches
+ * the crest at one corner).
+ *
+ * Shifting edge 0's bit (or vertex A's) left by `k` gives edge `k`'s (vertex `k`'s).
+ *
+ * The edge classes are Box3D's `b3MeshEdgeFlags` (types.h), which spell FLAT as "concave from both
+ * sides"; the corner class is this engine's.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TriangleEdgeFlags = {
+    None: 0,
+
+    FlatAB: 1,
+    FlatBC: 2,
+    FlatCA: 4,
+
+    ConcaveAB: 8,
+    ConcaveBC: 16,
+    ConcaveCA: 32,
+
+    FlatVertexA: 64,
+    FlatVertexB: 128,
+    FlatVertexC: 256,
+};
+
+/**
+ * The edge bits of a {@link TriangleEdgeFlags} word, FLAT and CONCAVE.
+ * @type {number}
+ */
+export const TRIANGLE_EDGE_BITS = 63;
+
+/**
+ * Cosine of the largest angle between two triangles' normals at which the edge they share still
+ * counts as FLAT: 5°, Box3D's `cos5Deg` (mesh.c, `b3IdentifyEdges`).
+ * @type {number}
+ */
+export const FLAT_EDGE_COS = 0.9962;

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

@@ -0,0 +1,42 @@
+/**
+ * Class of an edge two triangles share, seen from the first of them: {@link TriangleEdgeFlags.FlatAB},
+ * {@link TriangleEdgeFlags.ConcaveAB} or `0` (convex) — edge 0's bits; shift them left by `k` for the
+ * triangle's edge `k`.
+ *
+ * FLAT when the normals are within {@link FLAT_EDGE_COS} of each other, whichever way the surface bends;
+ * otherwise CONCAVE when the neighbour's far vertex lies on the outer side of this triangle's plane.
+ * Ported from Box3D's `b3IdentifyEdges` (mesh.c, MIT, Erin Catto), which tests the same two things
+ * with a signed volume.
+ *
+ * A normal of zero length (a degenerate triangle on either side) has no plane to compare: the edge
+ * is convex, a real edge, which is what an edge with nothing reliable behind it must be.
+ *
+ * @param {number} n1x outward normal of the triangle the edge is classified for, any length
+ * @param {number} n1y
+ * @param {number} n1z
+ * @param {number} n2x outward normal of the triangle across the edge, any length
+ * @param {number} n2y
+ * @param {number} n2z
+ * @param {number} dx the far vertex of the triangle across the edge, minus any point on the edge
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {number}
+ */
+export function tri3_classify_shared_edge(n1x: number, n1y: number, n1z: number, n2x: number, n2y: number, n2z: number, dx: number, dy: number, dz: number): number;
+/**
+ * {@link tri3_classify_shared_edge} with the two normals and the far-vertex offset read from arrays: the
+ * one place the arithmetic lives. For a caller that cannot have the call inlined, where nine numbers
+ * passed in would each be boxed into a new heap object (the class it returns is a small integer, which
+ * is not).
+ *
+ * @param {number[]|Float64Array} n1 outward normal of the triangle the edge is classified for
+ * @param {number} n1_offset
+ * @param {number[]|Float64Array} n2 outward normal of the triangle across the edge
+ * @param {number} n2_offset
+ * @param {number[]|Float64Array} d the far vertex of the triangle across the edge, minus any point on
+ *   the edge
+ * @param {number} d_offset
+ * @returns {number}
+ */
+export function tri3_classify_shared_edge_array(n1: number[] | Float64Array, n1_offset: number, n2: number[] | Float64Array, n2_offset: number, d: number[] | Float64Array, d_offset: number): number;
+//# sourceMappingURL=tri3_classify_shared_edge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_classify_shared_edge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_classify_shared_edge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAXW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB;AAKD;;;;;;;;;;;;;;GAcG;AACH,oDATW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YAErB,MAAM,GACJ,MAAM,CA0BlB"}

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

@@ -0,0 +1,85 @@
+import { FLAT_EDGE_COS, TriangleEdgeFlags } from "./TriangleEdgeFlags.js";
+
+/**
+ * Class of an edge two triangles share, seen from the first of them: {@link TriangleEdgeFlags.FlatAB},
+ * {@link TriangleEdgeFlags.ConcaveAB} or `0` (convex) — edge 0's bits; shift them left by `k` for the
+ * triangle's edge `k`.
+ *
+ * FLAT when the normals are within {@link FLAT_EDGE_COS} of each other, whichever way the surface bends;
+ * otherwise CONCAVE when the neighbour's far vertex lies on the outer side of this triangle's plane.
+ * Ported from Box3D's `b3IdentifyEdges` (mesh.c, MIT, Erin Catto), which tests the same two things
+ * with a signed volume.
+ *
+ * A normal of zero length (a degenerate triangle on either side) has no plane to compare: the edge
+ * is convex, a real edge, which is what an edge with nothing reliable behind it must be.
+ *
+ * @param {number} n1x outward normal of the triangle the edge is classified for, any length
+ * @param {number} n1y
+ * @param {number} n1z
+ * @param {number} n2x outward normal of the triangle across the edge, any length
+ * @param {number} n2y
+ * @param {number} n2z
+ * @param {number} dx the far vertex of the triangle across the edge, minus any point on the edge
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {number}
+ */
+export function tri3_classify_shared_edge(n1x, n1y, n1z, n2x, n2y, n2z, dx, dy, dz) {
+    const inputs = scalar_inputs;
+
+    inputs[0] = n1x;
+    inputs[1] = n1y;
+    inputs[2] = n1z;
+    inputs[3] = n2x;
+    inputs[4] = n2y;
+    inputs[5] = n2z;
+    inputs[6] = dx;
+    inputs[7] = dy;
+    inputs[8] = dz;
+
+    return tri3_classify_shared_edge_array(inputs, 0, inputs, 3, inputs, 6);
+}
+
+/** Where {@link tri3_classify_shared_edge} packs its vectors. */
+const scalar_inputs = new Float64Array(9);
+
+/**
+ * {@link tri3_classify_shared_edge} with the two normals and the far-vertex offset read from arrays: the
+ * one place the arithmetic lives. For a caller that cannot have the call inlined, where nine numbers
+ * passed in would each be boxed into a new heap object (the class it returns is a small integer, which
+ * is not).
+ *
+ * @param {number[]|Float64Array} n1 outward normal of the triangle the edge is classified for
+ * @param {number} n1_offset
+ * @param {number[]|Float64Array} n2 outward normal of the triangle across the edge
+ * @param {number} n2_offset
+ * @param {number[]|Float64Array} d the far vertex of the triangle across the edge, minus any point on
+ *   the edge
+ * @param {number} d_offset
+ * @returns {number}
+ */
+export function tri3_classify_shared_edge_array(n1, n1_offset, n2, n2_offset, d, d_offset) {
+    const n1x = n1[n1_offset], n1y = n1[n1_offset + 1], n1z = n1[n1_offset + 2];
+    const n2x = n2[n2_offset], n2y = n2[n2_offset + 1], n2z = n2[n2_offset + 2];
+    const dx = d[d_offset], dy = d[d_offset + 1], dz = d[d_offset + 2];
+
+    const len1_sqr = n1x * n1x + n1y * n1y + n1z * n1z;
+    const len2_sqr = n2x * n2x + n2y * n2y + n2z * n2z;
+
+    if (!(len1_sqr > 0) || !(len2_sqr > 0)) {
+        return 0;
+    }
+
+    const dot = n1x * n2x + n1y * n2y + n1z * n2z;
+
+    // cos > FLAT_EDGE_COS, without the square roots
+    if (dot > 0 && dot * dot > FLAT_EDGE_COS * FLAT_EDGE_COS * len1_sqr * len2_sqr) {
+        return TriangleEdgeFlags.FlatAB;
+    }
+
+    if (n1x * dx + n1y * dy + n1z * dz > 0) {
+        return TriangleEdgeFlags.ConcaveAB;
+    }
+
+    return 0;
+}

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

@@ -26,4 +26,17 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function tri3_closest_point(out: number[] | Float32Array | Float64Array, out_offset: number, px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+/**
+ * {@link tri3_closest_point} with the point and the triangle read from arrays, for a caller that has
+ * them there: a call V8 does not inline boxes each number passed to it, and the one it returns, into
+ * a new heap object. Writes the closest point only; it returns nothing.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for the closest point `(x, y, z)`
+ * @param {number} out_offset
+ * @param {number[]|Float64Array} point query point
+ * @param {number} point_offset
+ * @param {number[]|Float64Array} triangle apices A, B, C
+ * @param {number} triangle_offset
+ */
+export function tri3_closest_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, point: number[] | Float64Array, point_offset: number, triangle: number[] | Float64Array, triangle_offset: number): void;
 //# sourceMappingURL=tri3_closest_point.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_closest_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_closest_point.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqClB"}
+{"version":3,"file":"tri3_closest_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_closest_point.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqClB;AAED;;;;;;;;;;;GAWG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,QAoBhB"}

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

@@ -1,4 +1,7 @@
-import { tri3_closest_point_barycentric } from "./tri3_closest_point_barycentric.js";
+import {
+    tri3_closest_point_barycentric,
+    tri3_closest_point_barycentric_array
+} from "./tri3_closest_point_barycentric.js";
 
 // barycentric weights of the closest point, [u, v] with the third weight implied
 const scratch_barycentric = new Float64Array(2);
@@ -63,3 +66,35 @@ export function tri3_closest_point(
 
     return dx * dx + dy * dy + dz * dz;
 }
+
+/**
+ * {@link tri3_closest_point} with the point and the triangle read from arrays, for a caller that has
+ * them there: a call V8 does not inline boxes each number passed to it, and the one it returns, into
+ * a new heap object. Writes the closest point only; it returns nothing.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination for the closest point `(x, y, z)`
+ * @param {number} out_offset
+ * @param {number[]|Float64Array} point query point
+ * @param {number} point_offset
+ * @param {number[]|Float64Array} triangle apices A, B, C
+ * @param {number} triangle_offset
+ */
+export function tri3_closest_point_array(
+    out, out_offset,
+    point, point_offset,
+    triangle, triangle_offset
+) {
+    tri3_closest_point_barycentric_array(scratch_barycentric, 0, point, point_offset, triangle, triangle_offset);
+
+    const u = scratch_barycentric[0];
+    const v = scratch_barycentric[1];
+    const w = 1 - u - v;
+
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
+    out[out_offset] = u * ax + v * bx + w * cx;
+    out[out_offset + 1] = u * ay + v * by + w * cy;
+    out[out_offset + 2] = u * az + v * bz + w * cz;
+}

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

@@ -17,4 +17,18 @@
  * @returns {void}
  */
 export function tri3_closest_point_barycentric(result: number[], result_offset: number, px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): void;
+/**
+ * {@link tri3_closest_point_barycentric} with the point and the triangle read from arrays, and the
+ * one place its arithmetic lives. A call V8 does not inline boxes each number passed to it into a new
+ * heap object — twelve here — and this is past the size V8 inlines.
+ *
+ * @param {number[]|Float64Array} result `[u, v]`, the weights of A and B; C's is `1 - u - v`
+ * @param {number} result_offset
+ * @param {number[]|Float64Array} point reference point
+ * @param {number} point_offset
+ * @param {number[]|Float64Array} triangle apices A, B, C
+ * @param {number} triangle_offset
+ * @returns {void}
+ */
+export function tri3_closest_point_barycentric_array(result: number[] | Float64Array, result_offset: number, point: number[] | Float64Array, point_offset: number, triangle: number[] | Float64Array, triangle_offset: number): void;
 //# sourceMappingURL=tri3_closest_point_barycentric.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tri3_closest_point_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_closest_point_barycentric.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,uDAhBW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAyJhB"}
+{"version":3,"file":"tri3_closest_point_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_closest_point_barycentric.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,uDAhBW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAmBhB;AAMD;;;;;;;;;;;;GAYG;AACH,6DARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,GACJ,IAAI,CA6JhB"}

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

@@ -25,6 +25,46 @@ export function tri3_closest_point_barycentric(
     bx, by, bz,
     cx, cy, cz
 ) {
+    const point = scratch_point;
+    const triangle = scratch_triangle;
+
+    point[0] = px; point[1] = py; point[2] = pz;
+
+    triangle[0] = ax; triangle[1] = ay; triangle[2] = az;
+    triangle[3] = bx; triangle[4] = by; triangle[5] = bz;
+    triangle[6] = cx; triangle[7] = cy; triangle[8] = cz;
+
+    tri3_closest_point_barycentric_array(result, result_offset, point, 0, triangle, 0);
+}
+
+/** Where {@link tri3_closest_point_barycentric} packs its point and its triangle. */
+const scratch_point = new Float64Array(3);
+const scratch_triangle = new Float64Array(9);
+
+/**
+ * {@link tri3_closest_point_barycentric} with the point and the triangle read from arrays, and the
+ * one place its arithmetic lives. A call V8 does not inline boxes each number passed to it into a new
+ * heap object — twelve here — and this is past the size V8 inlines.
+ *
+ * @param {number[]|Float64Array} result `[u, v]`, the weights of A and B; C's is `1 - u - v`
+ * @param {number} result_offset
+ * @param {number[]|Float64Array} point reference point
+ * @param {number} point_offset
+ * @param {number[]|Float64Array} triangle apices A, B, C
+ * @param {number} triangle_offset
+ * @returns {void}
+ */
+export function tri3_closest_point_barycentric_array(
+    result, result_offset,
+    point, point_offset,
+    triangle, triangle_offset
+) {
+    const px = point[point_offset], py = point[point_offset + 1], pz = point[point_offset + 2];
+
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
     /*
      Adapted from three's `Triangle.getBarycoord`:
      https://github.com/mrdoob/three.js/blob/676e85dc7cd5971a6565c4152e9e6d8bdd20a2b7/src/math/Triangle.js#L222

package/src/core/geom/vec3/v3_quaternion_apply.d.ts

@@ -26,4 +26,23 @@
  * @param {number} qw unit quaternion w (last)
  */
 export function v3_quaternion_apply(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+/**
+ * {@link v3_quaternion_apply} with the vector and the quaternion read from arrays. For a caller whose
+ * inlining budget is spent: there a call to the scalar form is a real call, and a real call boxes each
+ * of its seven numbers into a new heap object.
+ *
+ * The arithmetic is the scalar form's, written out again rather than called (called from here, the
+ * scalar form would be one more call to inline wherever this is inlined, and its numbers would be
+ * boxed whenever it was not). The two must stay operation for operation the same.
+ *
+ * `out` may be `v`: the vector is read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} v
+ * @param {number} v_offset
+ * @param {number[]|Float32Array|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ */
+export function v3_quaternion_apply_array(out: number[] | Float32Array | Float64Array, out_offset: number, v: number[] | Float32Array | Float64Array, v_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number): void;
 //# sourceMappingURL=v3_quaternion_apply.d.ts.map

package/src/core/geom/vec3/v3_quaternion_apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_quaternion_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quaternion_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,yCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB"}
+{"version":3,"file":"v3_quaternion_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quaternion_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,yCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAchB"}

package/src/core/geom/vec3/v3_quaternion_apply.js

@@ -37,3 +37,35 @@ export function v3_quaternion_apply(out, out_offset, vx, vy, vz, qx, qy, qz, qw)
     out[out_offset + 1] = ty * qw - tw * qy - tz * qx + tx * qz;
     out[out_offset + 2] = tz * qw - tw * qz - tx * qy + ty * qx;
 }
+
+/**
+ * {@link v3_quaternion_apply} with the vector and the quaternion read from arrays. For a caller whose
+ * inlining budget is spent: there a call to the scalar form is a real call, and a real call boxes each
+ * of its seven numbers into a new heap object.
+ *
+ * The arithmetic is the scalar form's, written out again rather than called (called from here, the
+ * scalar form would be one more call to inline wherever this is inlined, and its numbers would be
+ * boxed whenever it was not). The two must stay operation for operation the same.
+ *
+ * `out` may be `v`: the vector is read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} v
+ * @param {number} v_offset
+ * @param {number[]|Float32Array|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ */
+export function v3_quaternion_apply_array(out, out_offset, v, v_offset, q, q_offset) {
+    const vx = v[v_offset], vy = v[v_offset + 1], vz = v[v_offset + 2];
+    const qx = q[q_offset], qy = q[q_offset + 1], qz = q[q_offset + 2], qw = q[q_offset + 3];
+
+    const tx =  qw * vx + qy * vz - qz * vy;
+    const ty =  qw * vy + qz * vx - qx * vz;
+    const tz =  qw * vz + qx * vy - qy * vx;
+    const tw = -qx * vx - qy * vy - qz * vz;
+
+    out[out_offset]     = tx * qw - tw * qx - ty * qz + tz * qy;
+    out[out_offset + 1] = ty * qw - tw * qy - tz * qx + tx * qz;
+    out[out_offset + 2] = tz * qw - tw * qz - tx * qy + ty * qx;
+}

package/src/core/geom/vec3/v3_quaternion_apply_inverse.d.ts

@@ -27,4 +27,23 @@
  * @param {number} qw unit quaternion w (last)
  */
 export function v3_quaternion_apply_inverse(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+/**
+ * {@link v3_quaternion_apply_inverse} with the vector and the quaternion read from arrays. For a
+ * caller whose inlining budget is spent: there a call to the scalar form is a real call, and a real
+ * call boxes each of its seven numbers into a new heap object.
+ *
+ * The arithmetic is the scalar form's, written out again rather than called: called from here, the
+ * scalar form would be one more call to inline wherever this is inlined, and the same seven numbers
+ * would be boxed whenever it was not. The two must stay operation for operation the same.
+ *
+ * `out` may be `v`: the vector is read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} v
+ * @param {number} v_offset
+ * @param {number[]|Float32Array|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ */
+export function v3_quaternion_apply_inverse_array(out: number[] | Float32Array | Float64Array, out_offset: number, v: number[] | Float32Array | Float64Array, v_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number): void;
 //# sourceMappingURL=v3_quaternion_apply_inverse.d.ts.map

package/src/core/geom/vec3/v3_quaternion_apply_inverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_quaternion_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quaternion_apply_inverse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB"}
+{"version":3,"file":"v3_quaternion_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quaternion_apply_inverse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAchB"}

package/src/core/geom/vec3/v3_quaternion_apply_inverse.js

@@ -39,3 +39,35 @@ export function v3_quaternion_apply_inverse(out, out_offset, vx, vy, vz, qx, qy,
     out[out_offset + 1] = ty * qw + tw * qy + tz * qx - tx * qz;
     out[out_offset + 2] = tz * qw + tw * qz + tx * qy - ty * qx;
 }
+
+/**
+ * {@link v3_quaternion_apply_inverse} with the vector and the quaternion read from arrays. For a
+ * caller whose inlining budget is spent: there a call to the scalar form is a real call, and a real
+ * call boxes each of its seven numbers into a new heap object.
+ *
+ * The arithmetic is the scalar form's, written out again rather than called: called from here, the
+ * scalar form would be one more call to inline wherever this is inlined, and the same seven numbers
+ * would be boxed whenever it was not. The two must stay operation for operation the same.
+ *
+ * `out` may be `v`: the vector is read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} v
+ * @param {number} v_offset
+ * @param {number[]|Float32Array|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ */
+export function v3_quaternion_apply_inverse_array(out, out_offset, v, v_offset, q, q_offset) {
+    const vx = v[v_offset], vy = v[v_offset + 1], vz = v[v_offset + 2];
+    const qx = q[q_offset], qy = q[q_offset + 1], qz = q[q_offset + 2], qw = q[q_offset + 3];
+
+    const tx = qw * vx - qy * vz + qz * vy;
+    const ty = qw * vy - qz * vx + qx * vz;
+    const tz = qw * vz - qx * vy + qy * vx;
+    const tw = qx * vx + qy * vy + qz * vz;
+
+    out[out_offset]     = tx * qw + tw * qx + ty * qz - tz * qy;
+    out[out_offset + 1] = ty * qw + tw * qy + tz * qx - tx * qz;
+    out[out_offset + 2] = tz * qw + tw * qz + tx * qy - ty * qx;
+}