@woosh/meep-engine 3.1.0 → 3.3.0

package/src/core/geom/3d/plane/orient3d_fast_point.js

@@ -1,47 +1,47 @@
-/**
- * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
- * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
- *
- * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
- * with respect to their winding.
- *
- * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
- * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
- * common case for point-in-solid tests.
- *
- * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
- * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
- *
- * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
- * @param {number} a index of the first plane point
- * @param {number} b index of the second plane point
- * @param {number} c index of the third plane point
- * @param {number} ex query point x
- * @param {number} ey query point y
- * @param {number} ez query point z
- * @returns {number}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function orient3d_fast_point(points, a, b, c, ex, ey, ez) {
-    const a3 = a * 3;
-    const b3 = b * 3;
-    const c3 = c * 3;
-
-    const adx = points[a3] - ex;
-    const ady = points[a3 + 1] - ey;
-    const adz = points[a3 + 2] - ez;
-
-    const bdx = points[b3] - ex;
-    const bdy = points[b3 + 1] - ey;
-    const bdz = points[b3 + 2] - ez;
-
-    const cdx = points[c3] - ex;
-    const cdy = points[c3 + 1] - ey;
-    const cdz = points[c3 + 2] - ez;
-
-    return adx * (bdy * cdz - bdz * cdy)
-        + bdx * (cdy * adz - cdz * ady)
-        + cdx * (ady * bdz - adz * bdy);
-}
+/**
+ * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
+ * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
+ *
+ * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
+ * with respect to their winding.
+ *
+ * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
+ * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
+ * common case for point-in-solid tests.
+ *
+ * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
+ * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
+ * @param {number} a index of the first plane point
+ * @param {number} b index of the second plane point
+ * @param {number} c index of the third plane point
+ * @param {number} ex query point x
+ * @param {number} ey query point y
+ * @param {number} ez query point z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function orient3d_fast_point(points, a, b, c, ex, ey, ez) {
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+
+    const adx = points[a3] - ex;
+    const ady = points[a3 + 1] - ey;
+    const adz = points[a3 + 2] - ez;
+
+    const bdx = points[b3] - ex;
+    const bdy = points[b3 + 1] - ey;
+    const bdz = points[b3 + 2] - ez;
+
+    const cdx = points[c3] - ex;
+    const cdy = points[c3 + 1] - ey;
+    const cdz = points[c3 + 2] - ez;
+
+    return adx * (bdy * cdz - bdz * cdy)
+        + bdx * (cdy * adz - cdz * ady)
+        + cdx * (ady * bdz - adz * bdy);
+}

package/src/core/geom/3d/plane/plane3_compute_convex_3_plane_intersection.js

@@ -1,7 +1,7 @@
-import { plane3_compute_3_plane_intersection } from "./plane3_compute_3_plane_intersection.js";
-
-/**
- * @deprecated Renamed to {@link plane3_compute_3_plane_intersection}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const plane3_compute_convex_3_plane_intersection = plane3_compute_3_plane_intersection;
+import { plane3_compute_3_plane_intersection } from "./plane3_compute_3_plane_intersection.js";
+
+/**
+ * @deprecated Renamed to {@link plane3_compute_3_plane_intersection}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const plane3_compute_convex_3_plane_intersection = plane3_compute_3_plane_intersection;

package/src/core/geom/3d/plane/plane3_compute_plane_intersection.js

@@ -1,7 +1,7 @@
-import { plane3_compute_intersection_objects } from "./plane3_compute_intersection_objects.js";
-
-/**
- * @deprecated Renamed to {@link plane3_compute_intersection_objects}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const plane3_compute_plane_intersection = plane3_compute_intersection_objects;
+import { plane3_compute_intersection_objects } from "./plane3_compute_intersection_objects.js";
+
+/**
+ * @deprecated Renamed to {@link plane3_compute_intersection_objects}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const plane3_compute_plane_intersection = plane3_compute_intersection_objects;

package/src/core/geom/3d/plane/plane3_intersect_plane.js

@@ -1,7 +1,7 @@
-import { plane3_compute_intersection } from "./plane3_compute_intersection.js";
-
-/**
- * @deprecated Renamed to {@link plane3_compute_intersection}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const plane3_intersect_plane = plane3_compute_intersection;
+import { plane3_compute_intersection } from "./plane3_compute_intersection.js";
+
+/**
+ * @deprecated Renamed to {@link plane3_compute_intersection}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const plane3_intersect_plane = plane3_compute_intersection;

package/src/core/geom/3d/plane/plane3_three_compute_convex_3_plane_intersection.js

@@ -1,7 +1,7 @@
-import { plane3_compute_3_plane_intersection_from_three } from "./plane3_compute_3_plane_intersection_from_three.js";
-
-/**
- * @deprecated Renamed to {@link plane3_compute_3_plane_intersection_from_three}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const plane3_three_compute_convex_3_plane_intersection = plane3_compute_3_plane_intersection_from_three;
+import { plane3_compute_3_plane_intersection_from_three } from "./plane3_compute_3_plane_intersection_from_three.js";
+
+/**
+ * @deprecated Renamed to {@link plane3_compute_3_plane_intersection_from_three}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const plane3_three_compute_convex_3_plane_intersection = plane3_compute_3_plane_intersection_from_three;

package/src/core/geom/3d/point/point3_raycast.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Ray ↔ point intersection in the point's LOCAL frame, where the point sits at the origin — the
+ * canonical pose of `PointShape3D`.
+ *
+ * A point encloses no volume and bounds no surface, so the only ray that meets it is one whose line
+ * passes exactly through the origin. In floating point that is effectively never true of a ray not
+ * built to satisfy it, and this function says so rather than pretending otherwise: the alternative,
+ * answering with the point's degenerate bounding box, differs only in that it also divides by a zero
+ * extent to invent a normal.
+ *
+ * Conventions (shared with {@link box3_raycast} / {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * The reported normal is `−direction`: the limit of the sphere normal as the radius goes to zero, and
+ * the only direction a point can offer.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function point3_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number): number;
+//# sourceMappingURL=point3_raycast.d.ts.map

package/src/core/geom/3d/point/point3_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/point/point3_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAdW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,CAoBlB"}

package/src/core/geom/3d/point/point3_raycast.js

@@ -0,0 +1,47 @@
+/**
+ * Ray ↔ point intersection in the point's LOCAL frame, where the point sits at the origin — the
+ * canonical pose of `PointShape3D`.
+ *
+ * A point encloses no volume and bounds no surface, so the only ray that meets it is one whose line
+ * passes exactly through the origin. In floating point that is effectively never true of a ray not
+ * built to satisfy it, and this function says so rather than pretending otherwise: the alternative,
+ * answering with the point's degenerate bounding box, differs only in that it also divides by a zero
+ * extent to invent a normal.
+ *
+ * Conventions (shared with {@link box3_raycast} / {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * The reported normal is `−direction`: the limit of the sphere normal as the radius goes to zero, and
+ * the only direction a point can offer.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function point3_raycast(outNormal, outOffset, ox, oy, oz, dx, dy, dz, tMax) {
+    // Distance along the ray of the closest approach to the origin.
+    const t = -(ox * dx + oy * dy + oz * dz);
+
+    if (t < 0 || t > tMax) return Infinity;
+
+    if (ox + dx * t !== 0 || oy + dy * t !== 0 || oz + dz * t !== 0) {
+        return Infinity; // the closest approach is not the point itself
+    }
+
+    outNormal[outOffset] = -dx;
+    outNormal[outOffset + 1] = -dy;
+    outNormal[outOffset + 2] = -dz;
+
+    return t;
+}

package/src/core/geom/3d/polygon/polygon3_compute_normal.js

@@ -1,60 +1,60 @@
-/**
- * Newell's method: the area-weighted normal of an arbitrary 3D polygon, written
- * to `result` at `result_offset` as a unit vector.
- *
- * Unlike taking the cross product of the first three vertices
- * (what {@link bt_mesh_compute_face_normals} does, correctly, for triangles),
- * this is defined for any vertex count, is immune to a collinear or coincident
- * leading triple, and for a non-planar polygon returns the normal of its
- * best-fit plane rather than of one arbitrary corner. That is exactly what
- * projecting an n-gon down to 2D needs.
- *
- * A polygon with no area -- fewer than three vertices, all collinear, or all
- * coincident -- has no normal; `result` is then written as `(0, 0, 0)`, which
- * callers can test with a length check. That is a real outcome of real data, not
- * an error.
- *
- * @param {ArrayLike<number>} result
- * @param {number} result_offset
- * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
- * @param {number} from first vertex index of the contour
- * @param {number} count number of vertices in the contour
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function polygon3_compute_normal(result, result_offset, points, from, count) {
-    let nx = 0;
-    let ny = 0;
-    let nz = 0;
-
-    const to = from + count;
-
-    for (let i = from; i < to; i++) {
-        const j = (i + 1 === to) ? from : i + 1;
-
-        const i3 = i * 3;
-        const j3 = j * 3;
-
-        const ax = points[i3], ay = points[i3 + 1], az = points[i3 + 2];
-        const bx = points[j3], by = points[j3 + 1], bz = points[j3 + 2];
-
-        nx += (ay - by) * (az + bz);
-        ny += (az - bz) * (ax + bx);
-        nz += (ax - bx) * (ay + by);
-    }
-
-    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
-
-    if (length === 0) {
-        result[result_offset] = 0;
-        result[result_offset + 1] = 0;
-        result[result_offset + 2] = 0;
-
-        return;
-    }
-
-    result[result_offset] = nx / length;
-    result[result_offset + 1] = ny / length;
-    result[result_offset + 2] = nz / length;
-}
+/**
+ * Newell's method: the area-weighted normal of an arbitrary 3D polygon, written
+ * to `result` at `result_offset` as a unit vector.
+ *
+ * Unlike taking the cross product of the first three vertices
+ * (what {@link bt_mesh_compute_face_normals} does, correctly, for triangles),
+ * this is defined for any vertex count, is immune to a collinear or coincident
+ * leading triple, and for a non-planar polygon returns the normal of its
+ * best-fit plane rather than of one arbitrary corner. That is exactly what
+ * projecting an n-gon down to 2D needs.
+ *
+ * A polygon with no area -- fewer than three vertices, all collinear, or all
+ * coincident -- has no normal; `result` is then written as `(0, 0, 0)`, which
+ * callers can test with a length check. That is a real outcome of real data, not
+ * an error.
+ *
+ * @param {ArrayLike<number>} result
+ * @param {number} result_offset
+ * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
+ * @param {number} from first vertex index of the contour
+ * @param {number} count number of vertices in the contour
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function polygon3_compute_normal(result, result_offset, points, from, count) {
+    let nx = 0;
+    let ny = 0;
+    let nz = 0;
+
+    const to = from + count;
+
+    for (let i = from; i < to; i++) {
+        const j = (i + 1 === to) ? from : i + 1;
+
+        const i3 = i * 3;
+        const j3 = j * 3;
+
+        const ax = points[i3], ay = points[i3 + 1], az = points[i3 + 2];
+        const bx = points[j3], by = points[j3 + 1], bz = points[j3 + 2];
+
+        nx += (ay - by) * (az + bz);
+        ny += (az - bz) * (ax + bx);
+        nz += (ax - bx) * (ay + by);
+    }
+
+    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+
+    if (length === 0) {
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+        result[result_offset + 2] = 0;
+
+        return;
+    }
+
+    result[result_offset] = nx / length;
+    result[result_offset + 1] = ny / length;
+    result[result_offset + 2] = nz / length;
+}

package/src/core/geom/3d/polygon/polygon3_triangulate.js

@@ -1,94 +1,94 @@
-import { assert } from "../../../assert.js";
-import { polygon2_triangulate } from "../../2d/polygon/polygon2_triangulate.js";
-
-/**
- * Projected (u, v) per vertex for the current call. Module-static and grown on
- * demand, matching {@link polygon2_triangulate}'s own storage -- and, like it,
- * this function is therefore not re-entrant.
- * @type {Float64Array}
- */
-let _projected = new Float64Array(0);
-
-/**
- * Triangulate a planar 3D polygon with holes, viewed along `-normal`.
- *
- * The polygon is projected to 2D by **dropping the axis the normal points most
- * strongly along** and keeping the other two verbatim, swapped when that
- * component is negative so the projection stays counter-clockwise as seen from
- * `+normal`. Nothing is rotated and no coordinate is recomputed, which is the
- * whole point: {@link polygon2_triangulate} decides exactly, and it can only do
- * that on coordinates that are exactly the input's. A rotation into a fitted
- * plane basis would round every vertex first and hand the exact predicate
- * approximate data.
- *
- * `normal` need not be normalised, but it must not be zero. Derive it with
- * {@link polygon3_compute_normal} when the caller has no authoritative one.
- *
- * Output indices address `points3` -- the same vertices the caller passed in --
- * and each triangle is counter-clockwise when viewed from `+normal`.
- *
- * @param {Uint32Array} result receives 3 point indices per triangle
- * @param {number} result_offset first index written in `result`
- * @param {ArrayLike<number>} points3 flat (x, y, z) triples, stride 3
- * @param {ArrayLike<number>} contour_ends exclusive end vertex index per contour
- * @param {number} contour_count number of contours; contour 0 is the outer boundary
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz polygon normal, need not be unit length
- * @returns {number} number of triangles written; see {@link polygon2_triangulate}
- *     for what a short count means
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function polygon3_triangulate(
-    result, result_offset,
-    points3, contour_ends, contour_count,
-    nx, ny, nz
-) {
-    assert.isArrayLike(points3, "points3");
-    assert.isPositiveInteger(contour_count, "contour_count");
-    assert.ok(nx !== 0 || ny !== 0 || nz !== 0, "polygon normal must not be zero");
-
-    const vertex_count = contour_ends[contour_count - 1];
-
-    if (vertex_count < 3) {
-        return 0;
-    }
-
-    if (_projected.length < vertex_count * 2) {
-        _projected = new Float64Array(vertex_count * 2);
-    }
-
-    const ax = Math.abs(nx);
-    const ay = Math.abs(ny);
-    const az = Math.abs(nz);
-
-    // Component offsets of the two axes kept, in the order that preserves
-    // counter-clockwise winding seen from +normal:
-    //   +x -> (y, z)    -x -> (z, y)
-    //   +y -> (z, x)    -y -> (x, z)
-    //   +z -> (x, y)    -z -> (y, x)
-    let u_axis;
-    let v_axis;
-
-    if (ax >= ay && ax >= az) {
-        u_axis = nx > 0 ? 1 : 2;
-        v_axis = nx > 0 ? 2 : 1;
-    } else if (ay >= az) {
-        u_axis = ny > 0 ? 2 : 0;
-        v_axis = ny > 0 ? 0 : 2;
-    } else {
-        u_axis = nz > 0 ? 0 : 1;
-        v_axis = nz > 0 ? 1 : 0;
-    }
-
-    for (let i = 0; i < vertex_count; i++) {
-        const i3 = i * 3;
-
-        _projected[i * 2] = points3[i3 + u_axis];
-        _projected[i * 2 + 1] = points3[i3 + v_axis];
-    }
-
-    return polygon2_triangulate(result, result_offset, _projected, contour_ends, contour_count);
-}
+import { assert } from "../../../assert.js";
+import { polygon2_triangulate } from "../../2d/polygon/polygon2_triangulate.js";
+
+/**
+ * Projected (u, v) per vertex for the current call. Module-static and grown on
+ * demand, matching {@link polygon2_triangulate}'s own storage -- and, like it,
+ * this function is therefore not re-entrant.
+ * @type {Float64Array}
+ */
+let _projected = new Float64Array(0);
+
+/**
+ * Triangulate a planar 3D polygon with holes, viewed along `-normal`.
+ *
+ * The polygon is projected to 2D by **dropping the axis the normal points most
+ * strongly along** and keeping the other two verbatim, swapped when that
+ * component is negative so the projection stays counter-clockwise as seen from
+ * `+normal`. Nothing is rotated and no coordinate is recomputed, which is the
+ * whole point: {@link polygon2_triangulate} decides exactly, and it can only do
+ * that on coordinates that are exactly the input's. A rotation into a fitted
+ * plane basis would round every vertex first and hand the exact predicate
+ * approximate data.
+ *
+ * `normal` need not be normalised, but it must not be zero. Derive it with
+ * {@link polygon3_compute_normal} when the caller has no authoritative one.
+ *
+ * Output indices address `points3` -- the same vertices the caller passed in --
+ * and each triangle is counter-clockwise when viewed from `+normal`.
+ *
+ * @param {Uint32Array} result receives 3 point indices per triangle
+ * @param {number} result_offset first index written in `result`
+ * @param {ArrayLike<number>} points3 flat (x, y, z) triples, stride 3
+ * @param {ArrayLike<number>} contour_ends exclusive end vertex index per contour
+ * @param {number} contour_count number of contours; contour 0 is the outer boundary
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz polygon normal, need not be unit length
+ * @returns {number} number of triangles written; see {@link polygon2_triangulate}
+ *     for what a short count means
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function polygon3_triangulate(
+    result, result_offset,
+    points3, contour_ends, contour_count,
+    nx, ny, nz
+) {
+    assert.isArrayLike(points3, "points3");
+    assert.isPositiveInteger(contour_count, "contour_count");
+    assert.ok(nx !== 0 || ny !== 0 || nz !== 0, "polygon normal must not be zero");
+
+    const vertex_count = contour_ends[contour_count - 1];
+
+    if (vertex_count < 3) {
+        return 0;
+    }
+
+    if (_projected.length < vertex_count * 2) {
+        _projected = new Float64Array(vertex_count * 2);
+    }
+
+    const ax = Math.abs(nx);
+    const ay = Math.abs(ny);
+    const az = Math.abs(nz);
+
+    // Component offsets of the two axes kept, in the order that preserves
+    // counter-clockwise winding seen from +normal:
+    //   +x -> (y, z)    -x -> (z, y)
+    //   +y -> (z, x)    -y -> (x, z)
+    //   +z -> (x, y)    -z -> (y, x)
+    let u_axis;
+    let v_axis;
+
+    if (ax >= ay && ax >= az) {
+        u_axis = nx > 0 ? 1 : 2;
+        v_axis = nx > 0 ? 2 : 1;
+    } else if (ay >= az) {
+        u_axis = ny > 0 ? 2 : 0;
+        v_axis = ny > 0 ? 0 : 2;
+    } else {
+        u_axis = nz > 0 ? 0 : 1;
+        v_axis = nz > 0 ? 1 : 0;
+    }
+
+    for (let i = 0; i < vertex_count; i++) {
+        const i3 = i * 3;
+
+        _projected[i * 2] = points3[i3 + u_axis];
+        _projected[i * 2 + 1] = points3[i3 + v_axis];
+    }
+
+    return polygon2_triangulate(result, result_offset, _projected, contour_ends, contour_count);
+}

package/src/core/geom/3d/polyhedron/convex_polyhedron3_raycast.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ray ↔ convex polyhedron intersection in the polyhedron's LOCAL frame, where the solid is given as
+ * its set of face half-spaces: four doubles per face `(nx, ny, nz, d)` with a UNIT OUTWARD normal and
+ * `d = n · v` for any vertex `v` on the face, so a point is inside iff `n · p − d ≤ 0` for every face.
+ * That is exactly the layout `ConvexHullShape3D` derives in `recompute`.
+ *
+ * Half-space interval clipping (Cyrus–Beck): the ray's parameter interval starts as `[−∞, +∞]` and each
+ * face plane clips it — a face the ray travels INTO (`n · d < 0`) can only raise the entry, one it
+ * travels OUT of can only lower the exit. The moment entry passes exit, the ray has missed the solid.
+ * Exact: no iteration, no tolerance, O(F) in the face count an authored hull carries.
+ *
+ * Conventions (shared with {@link box3_raycast} / {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first surface crossing at or after the origin within `tMax` is returned; a ray starting INSIDE
+ *    the solid returns its EXIT crossing;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * PRECONDITION: the normals face OUTWARD. This is the opposite of the frustum convention that
+ * {@link plane3_contains_point_within_set} takes (inward normals, inside = above every plane) — the two
+ * both consume a flat `(nx, ny, nz, d)` array and are not interchangeable. Feeding an inward-wound set
+ * here reports misses, because no point is on the far side of every face of a bounded solid.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit outward normal at the hit
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {Float64Array|number[]} planes face half-spaces, 4 per face `(nx, ny, nz, d)`
+ * @param {number} plane_count number of faces in `planes`
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function convex_polyhedron3_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, planes: Float64Array | number[], plane_count: number): number;
+//# sourceMappingURL=convex_polyhedron3_raycast.d.ts.map

package/src/core/geom/3d/polyhedron/convex_polyhedron3_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex_polyhedron3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/polyhedron/convex_polyhedron3_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,sDAhBW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,eACrB,MAAM,GACJ,MAAM,CA4DlB"}