@woosh/meep-engine 3.56.0 → 3.57.0

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_segment_penetrates_surface.js

@@ -1,133 +1,128 @@
-import {
-    COLUMN_CHILD_1,
-    COLUMN_CHILD_2,
-    COLUMN_USER_DATA,
-    ELEMENT_WORD_COUNT,
-    NULL_NODE
-} from "../../../../../../bvh2/bvh3/BVH.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
-
-// Plane-side slack and barycentric slack. Mesh vertices are float32, so a segment endpoint that lies ON
-// a triangle sits within ~coord*2^-23 of its plane; PLANE_EPS keeps those (and grazing/coplanar pieces)
-// from registering as a crossing. Only a genuinely transversal piece -- strictly on opposite sides of a
-// triangle's plane and crossing its interior away from its own endpoints -- counts as a penetration.
-const PLANE_EPS = 1e-3;
-const BARY_EPS = 1e-6;
-
-const _coords = new Float32Array(3);
-const _stack = new Uint32Array(1024); // DFS node stack; navmesh BVHs are shallow (depth ~ log2(faces))
-
-/** Standard slab test: does the segment p + t*d, t in [0,1], intersect the AABB [min,max]? */
-function segment_intersects_aabb(minx, miny, minz, maxx, maxy, maxz, px, py, pz, dx, dy, dz) {
-    let tmin = 0, tmax = 1;
-
-    if (dx > -1e-12 && dx < 1e-12) { if (px < minx || px > maxx) return false; }
-    else { let t1 = (minx - px) / dx, t2 = (maxx - px) / dx; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
-
-    if (dy > -1e-12 && dy < 1e-12) { if (py < miny || py > maxy) return false; }
-    else { let t1 = (miny - py) / dy, t2 = (maxy - py) / dy; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
-
-    if (dz > -1e-12 && dz < 1e-12) { if (pz < minz || pz > maxz) return false; }
-    else { let t1 = (minz - pz) / dz, t2 = (maxz - pz) / dz; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
-
-    return true;
-}
-
-/** True if segment (px,py,pz)->(qx,qy,qz) crosses the interior of triangle (a,b,c) transversally. */
-function segment_crosses_triangle(px, py, pz, qx, qy, qz, ax, ay, az, bx, by, bz, cx, cy, cz) {
-    const ux = bx - ax, uy = by - ay, uz = bz - az;
-    const vx = cx - ax, vy = cy - ay, vz = cz - az;
-    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
-    const nlen = Math.hypot(nx, ny, nz);
-    if (nlen < 1e-12) return false; // degenerate triangle
-
-    const dP = ((px - ax) * nx + (py - ay) * ny + (pz - az) * nz) / nlen;
-    const dQ = ((qx - ax) * nx + (qy - ay) * ny + (qz - az) * nz) / nlen;
-
-    // must cross the plane strictly (not coplanar, not endpoint-on-plane)
-    if (!((dP > PLANE_EPS && dQ < -PLANE_EPS) || (dP < -PLANE_EPS && dQ > PLANE_EPS))) return false;
-
-    const t = dP / (dP - dQ);
-    if (t <= PLANE_EPS || t >= 1 - PLANE_EPS) return false; // crossing at/near an endpoint (on the surface)
-
-    // crossing point, tested for containment via barycentric coordinates in the triangle plane
-    const wx = px + (qx - px) * t - ax, wy = py + (qy - py) * t - ay, wz = pz + (qz - pz) * t - az;
-    const d00 = ux * ux + uy * uy + uz * uz, d01 = ux * vx + uy * vy + uz * vz, d11 = vx * vx + vy * vy + vz * vz;
-    const d20 = wx * ux + wy * uy + wz * uz, d21 = wx * vx + wy * vy + wz * vz;
-    const denom = d00 * d11 - d01 * d01;
-    if (denom > -1e-18 && denom < 1e-18) return false;
-    const s = (d11 * d20 - d01 * d21) / denom;
-    const w = (d00 * d21 - d01 * d20) / denom;
-
-    return s >= -BARY_EPS && w >= -BARY_EPS && s + w <= 1 + BARY_EPS;
-}
-
-/**
- * Does the segment (ax,ay,az)->(bx,by,bz) pass THROUGH the mesh surface -- cross the interior of any
- * triangle transversally (entering one side, exiting the other) strictly between its endpoints?
- *
- * This is the "penetration" test for a navmesh path piece. A piece that hugs the surface (coplanar with
- * it) or flies over / under it -- a corner-only waypoint chord on a non-planar surface -- does NOT
- * penetrate; a piece that tunnels through a wall or floor does. Endpoints lying on the surface (every
- * path waypoint) are not penetrations.
- *
- * @param {BVH} bvh built by bt_mesh_build_face_bvh over `mesh`
- * @param {BinaryTopology} mesh triangle mesh
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} bx
- * @param {number} by
- * @param {number} bz
- * @returns {boolean}
- */
-export function bt_mesh_segment_penetrates_surface(bvh, mesh, ax, ay, az, bx, by, bz) {
-    const root = bvh.root;
-    if (root === NULL_NODE) return false;
-
-    const float32 = bvh.__data_float32;
-    const uint32 = bvh.__data_uint32;
-    const dx = bx - ax, dy = by - ay, dz = bz - az;
-
-    let sp = 0;
-    _stack[sp++] = root;
-
-    while (sp > 0) {
-        const node = _stack[--sp];
-        const address = node * ELEMENT_WORD_COUNT;
-
-        if (!segment_intersects_aabb(
-            float32[address], float32[address + 1], float32[address + 2],
-            float32[address + 3], float32[address + 4], float32[address + 5],
-            ax, ay, az, dx, dy, dz
-        )) {
-            continue;
-        }
-
-        const child_1 = uint32[address + COLUMN_CHILD_1];
-        if (child_1 !== NULL_NODE) {
-            _stack[sp++] = child_1;
-            _stack[sp++] = uint32[address + COLUMN_CHILD_2];
-            continue;
-        }
-
-        const face_id = uint32[address + COLUMN_USER_DATA];
-        const loop_a = mesh.face_read_loop(face_id);
-        if (loop_a === NULL_POINTER) continue;
-        const loop_b = mesh.loop_read_next(loop_a);
-        const loop_c = mesh.loop_read_next(loop_b);
-
-        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_a));
-        const tax = _coords[0], tay = _coords[1], taz = _coords[2];
-        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_b));
-        const tbx = _coords[0], tby = _coords[1], tbz = _coords[2];
-        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_c));
-        const tcx = _coords[0], tcy = _coords[1], tcz = _coords[2];
-
-        if (segment_crosses_triangle(ax, ay, az, bx, by, bz, tax, tay, taz, tbx, tby, tbz, tcx, tcy, tcz)) {
-            return true;
-        }
-    }
-
-    return false;
-}
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../../../../../../bvh2/bvh3/BVH.js";
+import { bt_face_read_triangle_coordinates } from "./bt_face_read_triangle.js";
+
+// Plane-side slack and barycentric slack. Mesh vertices are float32, so a segment endpoint that lies ON
+// a triangle sits within ~coord*2^-23 of its plane; PLANE_EPS keeps those (and grazing/coplanar pieces)
+// from registering as a crossing. Only a genuinely transversal piece -- strictly on opposite sides of a
+// triangle's plane and crossing its interior away from its own endpoints -- counts as a penetration.
+const PLANE_EPS = 1e-3;
+const BARY_EPS = 1e-6;
+
+const _coords = new Float32Array(9);
+const _stack = new Uint32Array(1024); // DFS node stack; navmesh BVHs are shallow (depth ~ log2(faces))
+
+/** Standard slab test: does the segment p + t*d, t in [0,1], intersect the AABB [min,max]? */
+function segment_intersects_aabb(minx, miny, minz, maxx, maxy, maxz, px, py, pz, dx, dy, dz) {
+    let tmin = 0, tmax = 1;
+
+    if (dx > -1e-12 && dx < 1e-12) { if (px < minx || px > maxx) return false; }
+    else { let t1 = (minx - px) / dx, t2 = (maxx - px) / dx; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    if (dy > -1e-12 && dy < 1e-12) { if (py < miny || py > maxy) return false; }
+    else { let t1 = (miny - py) / dy, t2 = (maxy - py) / dy; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    if (dz > -1e-12 && dz < 1e-12) { if (pz < minz || pz > maxz) return false; }
+    else { let t1 = (minz - pz) / dz, t2 = (maxz - pz) / dz; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    return true;
+}
+
+/** True if segment (px,py,pz)->(qx,qy,qz) crosses the interior of triangle (a,b,c) transversally. */
+function segment_crosses_triangle(px, py, pz, qx, qy, qz, ax, ay, az, bx, by, bz, cx, cy, cz) {
+    const ux = bx - ax, uy = by - ay, uz = bz - az;
+    const vx = cx - ax, vy = cy - ay, vz = cz - az;
+    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const nlen = Math.hypot(nx, ny, nz);
+    if (nlen < 1e-12) return false; // degenerate triangle
+
+    const dP = ((px - ax) * nx + (py - ay) * ny + (pz - az) * nz) / nlen;
+    const dQ = ((qx - ax) * nx + (qy - ay) * ny + (qz - az) * nz) / nlen;
+
+    // must cross the plane strictly (not coplanar, not endpoint-on-plane)
+    if (!((dP > PLANE_EPS && dQ < -PLANE_EPS) || (dP < -PLANE_EPS && dQ > PLANE_EPS))) return false;
+
+    const t = dP / (dP - dQ);
+    if (t <= PLANE_EPS || t >= 1 - PLANE_EPS) return false; // crossing at/near an endpoint (on the surface)
+
+    // crossing point, tested for containment via barycentric coordinates in the triangle plane
+    const wx = px + (qx - px) * t - ax, wy = py + (qy - py) * t - ay, wz = pz + (qz - pz) * t - az;
+    const d00 = ux * ux + uy * uy + uz * uz, d01 = ux * vx + uy * vy + uz * vz, d11 = vx * vx + vy * vy + vz * vz;
+    const d20 = wx * ux + wy * uy + wz * uz, d21 = wx * vx + wy * vy + wz * vz;
+    const denom = d00 * d11 - d01 * d01;
+    if (denom > -1e-18 && denom < 1e-18) return false;
+    const s = (d11 * d20 - d01 * d21) / denom;
+    const w = (d00 * d21 - d01 * d20) / denom;
+
+    return s >= -BARY_EPS && w >= -BARY_EPS && s + w <= 1 + BARY_EPS;
+}
+
+/**
+ * Does the segment (ax,ay,az)->(bx,by,bz) pass THROUGH the mesh surface -- cross the interior of any
+ * triangle transversally (entering one side, exiting the other) strictly between its endpoints?
+ *
+ * This is the "penetration" test for a navmesh path piece. A piece that hugs the surface (coplanar with
+ * it) or flies over / under it -- a corner-only waypoint chord on a non-planar surface -- does NOT
+ * penetrate; a piece that tunnels through a wall or floor does. Endpoints lying on the surface (every
+ * path waypoint) are not penetrations.
+ *
+ * @param {BVH} bvh built by bt_mesh_build_face_bvh over `mesh`
+ * @param {BinaryTopology} mesh triangle mesh
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @returns {boolean}
+ */
+export function bt_mesh_segment_penetrates_surface(bvh, mesh, ax, ay, az, bx, by, bz) {
+    const root = bvh.root;
+    if (root === NULL_NODE) return false;
+
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+    const dx = bx - ax, dy = by - ay, dz = bz - az;
+
+    let sp = 0;
+    _stack[sp++] = root;
+
+    while (sp > 0) {
+        const node = _stack[--sp];
+        const address = node * ELEMENT_WORD_COUNT;
+
+        if (!segment_intersects_aabb(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            ax, ay, az, dx, dy, dz
+        )) {
+            continue;
+        }
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+        if (child_1 !== NULL_NODE) {
+            _stack[sp++] = child_1;
+            _stack[sp++] = uint32[address + COLUMN_CHILD_2];
+            continue;
+        }
+
+        const face_id = uint32[address + COLUMN_USER_DATA];
+        if (!bt_face_read_triangle_coordinates(_coords, 0, mesh, face_id)) continue;
+
+        if (segment_crosses_triangle(
+            ax, ay, az, bx, by, bz,
+            _coords[0], _coords[1], _coords[2],
+            _coords[3], _coords[4], _coords[5],
+            _coords[6], _coords[7], _coords[8]
+        )) {
+            return true;
+        }
+    }
+
+    return false;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.d.ts

@@ -1,17 +1,3 @@
-/**
- * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
- * id. The BVH is cleared first, so it may be reused across calls.
- *
- * Shared by the tetrahedral carver and the interior-point sampler, which each carried a token-identical
- * copy of this loop.
- *
- * @param {BVH} bvh destination, released and refilled
- * @param {BinaryTopology} mesh surface mesh
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function bt_mesh_build_surface_triangle_bvh(bvh: BVH, mesh: BinaryTopology): void;
 /**
  * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
  * point-in-closed-surface tests.
@@ -32,4 +18,12 @@ export const SURFACE_PARITY_RAY_DIRECTIONS: number[];
  * @type {number}
  */
 export const SURFACE_PARITY_RAY_COUNT: number;
+/**
+ * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
+ * id. The BVH is cleared first, so it may be reused across calls.
+ *
+ * @deprecated Use {@link bt_mesh_build_face_bvh} instead
+ * @type {(bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void}
+ */
+export const bt_mesh_build_surface_triangle_bvh: (bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void;
 //# sourceMappingURL=bt_mesh_surface_ray_parity.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_surface_ray_parity.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;GAYG;AACH,yFAwCC;AA/ED;;;;;;;;;;;;;GAaG;AACH,4CAFU,MAAM,EAAE,CAMhB;AAEF;;;GAGG;AACH,uCAFU,MAAM,CAEiE"}
+{"version":3,"file":"bt_mesh_surface_ray_parity.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,4CAFU,MAAM,EAAE,CAMhB;AAEF;;;GAGG;AACH,uCAFU,MAAM,CAEiE;AAEjF;;;;;;GAMG;AACH,iDAFU,CAAC,GAAG,EAAE,OAAO,oCAAoC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,sBAAsB,EAAE,cAAc,KAAK,IAAI,CAErD"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js

@@ -1,82 +1,36 @@
-/**
- * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
- * point-in-closed-surface tests.
- *
- * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
- * three independent directions settle the vote correctly except in vanishingly improbable configurations.
- *
- * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
- * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
- * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
- * copy would silently have given the two classifiers different tie-breaking on the same mesh.
- *
- * @type {number[]}
- */
-export const SURFACE_PARITY_RAY_DIRECTIONS = [
-    0.97123, 0.18927, 0.14431,
-    0.34219, 0.91283, -0.22971,
-    -0.51237, 0.27894, 0.81235,
-];
-
-/**
- * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
- * @type {number}
- */
-export const SURFACE_PARITY_RAY_COUNT = SURFACE_PARITY_RAY_DIRECTIONS.length / 3;
-
-/**
- * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
- * id. The BVH is cleared first, so it may be reused across calls.
- *
- * Shared by the tetrahedral carver and the interior-point sampler, which each carried a token-identical
- * copy of this loop.
- *
- * @param {BVH} bvh destination, released and refilled
- * @param {BinaryTopology} mesh surface mesh
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function bt_mesh_build_surface_triangle_bvh(bvh, mesh) {
-    bvh.release_all();
-
-    const face_count = mesh.faces.size;
-    const v = scratch_coordinate;
-
-    for (let f = 0; f < face_count; f++) {
-        if (!mesh.faces.is_allocated(f)) {
-            continue;
-        }
-
-        const l0 = mesh.face_read_loop(f);
-        const l1 = mesh.loop_read_next(l0);
-        const l2 = mesh.loop_read_next(l1);
-
-        const v0 = mesh.loop_read_vertex(l0);
-        const v1 = mesh.loop_read_vertex(l1);
-        const v2 = mesh.loop_read_vertex(l2);
-
-        mesh.vertex_read_coordinate(v, 0, v0);
-
-        let minx = v[0], miny = v[1], minz = v[2];
-        let maxx = v[0], maxy = v[1], maxz = v[2];
-
-        mesh.vertex_read_coordinate(v, 0, v1);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        mesh.vertex_read_coordinate(v, 0, v2);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        const node = bvh.allocate_node();
-
-        bvh.node_set_user_data(node, f);
-        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
-        bvh.insert_leaf(node);
-    }
-}
-
-const scratch_coordinate = [0, 0, 0];
+import { bt_mesh_build_face_bvh } from "./bt_mesh_build_face_bvh.js";
+
+/**
+ * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
+ * point-in-closed-surface tests.
+ *
+ * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
+ * three independent directions settle the vote correctly except in vanishingly improbable configurations.
+ *
+ * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
+ * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
+ * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
+ * copy would silently have given the two classifiers different tie-breaking on the same mesh.
+ *
+ * @type {number[]}
+ */
+export const SURFACE_PARITY_RAY_DIRECTIONS = [
+    0.97123, 0.18927, 0.14431,
+    0.34219, 0.91283, -0.22971,
+    -0.51237, 0.27894, 0.81235,
+];
+
+/**
+ * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
+ * @type {number}
+ */
+export const SURFACE_PARITY_RAY_COUNT = SURFACE_PARITY_RAY_DIRECTIONS.length / 3;
+
+/**
+ * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
+ * id. The BVH is cleared first, so it may be reused across calls.
+ *
+ * @deprecated Use {@link bt_mesh_build_face_bvh} instead
+ * @type {(bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void}
+ */
+export const bt_mesh_build_surface_triangle_bvh = bt_mesh_build_face_bvh;

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

@@ -1 +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,CAoJnB;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAXW,OAAO,qBAAqB,EAAE,aAAa,YAC3C,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,YACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBACpD,MAAM,GACJ,OAAO,CAmKnB"}
+{"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,CAoJnB;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAXW,OAAO,qBAAqB,EAAE,aAAa,YAC3C,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,YACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBACpD,MAAM,GACJ,OAAO,CA0BnB"}

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

@@ -206,149 +206,12 @@ export function tri3_ray_intersection_triangle_array(
     const cy = triangle[triangle_offset + 7];
     const cz = triangle[triangle_offset + 8];
 
-    // Finite primitive numbers keep the valid path unboxed. The fallback
-    // preserves the scalar form's validation order and diagnostic messages.
-    if (!(Number.isFinite(ax) && Number.isFinite(ay) && Number.isFinite(az)
-        && Number.isFinite(bx) && Number.isFinite(by) && Number.isFinite(bz)
-        && Number.isFinite(cx) && Number.isFinite(cy) && Number.isFinite(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;
-
-    // `normal_x/y/z` is the raw `edge1 x edge2`, whose length is twice the triangle's area - it was
-    // written straight into `SurfacePoint3.normal`, which is documented as a surface normal and is
-    // a unit vector out of every other producer in the tree.
-    //
-    // NOTE: normalised but NOT turned to meet the ray, unlike `tri3_raycast`. This normal keeps the
-    // winding's facing on purpose: `StaticSceneBVH.raycast_nearest` derives `geometric_back_face`
-    // from `dot(normal, direction)`, and a normal pre-flipped toward the ray would report every hit
-    // as front-facing.
-    const normal_length = Math.sqrt(normal_x * normal_x + normal_y * normal_y + normal_z * normal_z);
-
-    const inv_normal_length = 1 / normal_length;
-
-    result.normal.set(
-        normal_x * inv_normal_length,
-        normal_y * inv_normal_length,
-        normal_z * inv_normal_length
-    );
-
-    result.position.set(
-        direction_x * t + origin_x,
-        direction_y * t + origin_y,
-        direction_z * t + origin_z,
+    return tri3_ray_intersection(
+        result,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
     );
-
-    return true;
 }

package/src/core/geom/ConicRay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConicRay.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/ConicRay.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH;IAuLI;;;;;;;OAOG;IACH,sBANW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,GACJ,QAAQ,CAkBpB;IA7MD;;;;OAIG;IACH,oBAFU,OAAO,CAEgB;IAEjC;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAMnB;IAED;;;;;OAKG;IACH,qBAJW,QAAQ,cACR,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,GACL,OAAO,CAMnB;IAED;;;;;OAKG;IACH,gDAFW,OAAO,QA2EjB;IA6BL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B;;kBAUS,MAAM;;oBApOI,cAAc"}
+{"version":3,"file":"ConicRay.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/ConicRay.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH;IA+KI;;;;;;;OAOG;IACH,sBANW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,GACJ,QAAQ,CAkBpB;IArMD;;;;OAIG;IACH,oBAFU,OAAO,CAEgB;IAEjC;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAMnB;IAED;;;;;OAKG;IACH,qBAJW,QAAQ,cACR,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,GACL,OAAO,CAMnB;IAED;;;;;OAKG;IACH,gDAFW,OAAO,QAmEjB;IA6BL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B;;kBAUS,MAAM;;oBA7NI,cAAc"}