@woosh/meep-engine 3.41.0 → 3.43.0

package/src/core/geom/3d/frustum/frustum3_compute_closest_point.js

@@ -1,172 +1,207 @@
-import { v3_distance_above_plane } from "../../vec3/v3_distance_above_plane.js";
-import Vector3 from "../../Vector3.js";
-import { plane3_compute_3_plane_intersection } from "../plane/plane3_compute_3_plane_intersection.js";
-import { plane3_compute_intersection } from "../plane/plane3_compute_intersection.js";
-import { plane3_project_point } from "../plane/plane3_project_point.js";
-import { ray3_compute_closest_point } from "../ray/ray3_compute_closest_point.js";
-
-/**
- * Indices into the caller's plane list, for the planes the target lies outside of.
- * @type {number[]}
- */
-const scratch_outer_planes = [];
-
-const scratch_v3_0 = new Vector3();
-
-const scratch_v3_1 = new Vector3();
-
-/**
- *
- * @type {number[]}
- */
-const scratch_v3_array = [];
-
-/**
- * How many projection rounds the four-or-more-planes fallback takes before it settles for where it
- * has got to. Bounded rather than convergent: the loop must not be able to spin on a degenerate
- * frustum.
- * @type {number}
- */
-const CLAMP_ITERATION_LIMIT = 32;
-
-/**
- * The point inside a convex frustum nearest to a target point, and whether the target was already
- * inside it.
- *
- * **A plane is a `Vector4`**: `x, y, z` its normal and `w` its constant, inside where
- * `dot(normal, p) + w` is non-negative. That is the same four numbers every frustum query in the
- * tree reads and what `camera_active_frustum` publishes; it used to be a three `Plane`, whose
- * `normal`/`constant` pair is the same thing wearing an object (X15d).
- *
- * @param {Vector3} result
- * @param {Vector4[]} planes
- * @param {number} target_x
- * @param {number} target_y
- * @param {number} target_z
- * @returns {boolean} if point is inside the frustum - true, false otherwise
- */
-export function frustum3_compute_closest_point(result, planes, target_x, target_y, target_z) {
-    let j;
-
-    let outside_plane_count = 0;
-
-    const plane_count = planes.length;
-
-    for (j = 0; j < plane_count; j++) {
-
-        const plane = planes[j];
-
-        const distance = v3_distance_above_plane(
-            target_x, target_y, target_z,
-            plane.x, plane.y, plane.z, plane.w
-        );
-
-        if (distance < 0) {
-
-            scratch_outer_planes[outside_plane_count] = j;
-
-            outside_plane_count++;
-
-        }
-
-    }
-
-    if (outside_plane_count === 0) {
-        result.set(target_x, target_y, target_z);
-
-        return true;
-    }
-
-    // point is outside the frustum
-
-    if (outside_plane_count === 1) {
-        const plane_0 = planes[scratch_outer_planes[0]];
-
-        // point lies outside exactly one plane
-        plane3_project_point(result, target_x, target_y, target_z, plane_0.x, plane_0.y, plane_0.z, plane_0.w);
-    } else if (outside_plane_count === 2) {
-        // outside two planes, nearest point lies on the intersection line of two planes
-
-        const plane_0 = planes[scratch_outer_planes[0]];
-        const plane_1 = planes[scratch_outer_planes[1]];
-
-        const intersection_exists = plane3_compute_intersection(
-            scratch_v3_0, scratch_v3_1,
-            plane_0.x, plane_0.y, plane_0.z, plane_0.w,
-            plane_1.x, plane_1.y, plane_1.z, plane_1.w
-        );
-
-        if (!intersection_exists) {
-            throw new Error('Planes are parallel and do not intersect, likely an invalid frustum');
-        }
-
-        ray3_compute_closest_point(result,
-            scratch_v3_0.x, scratch_v3_0.y, scratch_v3_0.z,
-            scratch_v3_1.x, scratch_v3_1.y, scratch_v3_1.z,
-            target_x, target_y, target_z
-        );
-    } else if (outside_plane_count === 3) {
-        // outside 3 planes, nearest point is intersect of 3 planes
-        const plane_0 = planes[scratch_outer_planes[0]];
-        const plane_1 = planes[scratch_outer_planes[1]];
-        const plane_2 = planes[scratch_outer_planes[2]];
-
-        plane3_compute_3_plane_intersection(
-            scratch_v3_array, 0,
-            plane_0.x, plane_0.y, plane_0.z, plane_0.w,
-            plane_1.x, plane_1.y, plane_1.z, plane_1.w,
-            plane_2.x, plane_2.y, plane_2.z, plane_2.w
-        );
-
-        result.fromArray(scratch_v3_array, 0)
-    } else {
-        // Four or more violated planes has no closed form here, and a perspective frustum reaches
-        // that easily: its side planes all pass through the apex, so any point behind the camera is
-        // outside near, left, right, top and bottom at once. Falling out of the chain left `result`
-        // holding whatever the caller's vector had — with a reused scratch, the *previous* query's
-        // answer, which reads as a plausibly placed point rather than as a failure.
-        //
-        // Walk the point back in by repeatedly projecting it onto whichever plane it violates
-        // most. For a convex body that converges into the intersection; it is not guaranteed to be
-        // the exact nearest point, but it is inside, and it is written.
-        let px = target_x;
-        let py = target_y;
-        let pz = target_z;
-
-        for (let iteration = 0; iteration < CLAMP_ITERATION_LIMIT; iteration++) {
-            let worst_plane = -1;
-            let worst_distance = 0;
-
-            for (j = 0; j < plane_count; j++) {
-                const plane = planes[j];
-
-                const distance = v3_distance_above_plane(
-                    px, py, pz,
-                    plane.x, plane.y, plane.z, plane.w
-                );
-
-                if (distance < worst_distance) {
-                    worst_distance = distance;
-                    worst_plane = j;
-                }
-            }
-
-            if (worst_plane === -1) {
-                // inside every plane
-                break;
-            }
-
-            const plane = planes[worst_plane];
-
-            plane3_project_point(scratch_v3_0, px, py, pz, plane.x, plane.y, plane.z, plane.w);
-
-            px = scratch_v3_0.x;
-            py = scratch_v3_0.y;
-            pz = scratch_v3_0.z;
-        }
-
-        result.set(px, py, pz);
-    }
-
-    return false;
-}
+import { v3_distance_above_plane } from "../../vec3/v3_distance_above_plane.js";
+import Vector3 from "../../Vector3.js";
+import { plane3_compute_intersection } from "../plane/plane3_compute_intersection.js";
+import { plane3_project_point } from "../plane/plane3_project_point.js";
+
+/**
+ * Indices into the caller's plane list, for the planes the target lies outside of.
+ * @type {number[]}
+ */
+const scratch_outer_planes = [];
+
+const scratch_v3_0 = new Vector3();
+
+const scratch_v3_1 = new Vector3();
+
+/**
+ * How many projection rounds the degenerate-edge fallback takes before it settles for where it
+ * has got to. Bounded rather than convergent: the loop must not be able to spin on a degenerate
+ * frustum.
+ * @type {number}
+ */
+const CLAMP_ITERATION_LIMIT = 32;
+
+/**
+ * The point inside a convex frustum nearest to a target point, and whether the target was already
+ * inside it.
+ *
+ * **A plane is a `Vector4`**: `x, y, z` its normal and `w` its constant, inside where
+ * `dot(normal, p) + w` is non-negative. That is the same four numbers every frustum query in the
+ * tree reads and what `camera_active_frustum` publishes; it used to be a three `Plane`, whose
+ * `normal`/`constant` pair is the same thing wearing an object (X15d).
+ *
+ * @param {Vector3} result
+ * @param {Vector4[]} planes
+ * @param {number} target_x
+ * @param {number} target_y
+ * @param {number} target_z
+ * @returns {boolean} if point is inside the frustum - true, false otherwise
+ */
+export function frustum3_compute_closest_point(result, planes, target_x, target_y, target_z) {
+    let j;
+
+    let outside_plane_count = 0;
+
+    const plane_count = planes.length;
+
+    for (j = 0; j < plane_count; j++) {
+
+        const plane = planes[j];
+
+        const distance = v3_distance_above_plane(
+            target_x, target_y, target_z,
+            plane.x, plane.y, plane.z, plane.w
+        );
+
+        if (distance < 0) {
+
+            scratch_outer_planes[outside_plane_count] = j;
+
+            outside_plane_count++;
+
+        }
+
+    }
+
+    if (outside_plane_count === 0) {
+        result.set(target_x, target_y, target_z);
+
+        return true;
+    }
+
+    // point is outside the frustum
+
+    // Several violated planes need not all meet at the nearest point. A feasible face projection
+    // attains that halfspace's distance lower bound, so it is also nearest to the whole frustum.
+    for (let candidate = 0; candidate < outside_plane_count; candidate++) {
+        const face = planes[scratch_outer_planes[candidate]];
+        // Stored Float32 normals are only approximately unit length.
+        const normal_length_squared = face.x * face.x + face.y * face.y + face.z * face.z;
+        const offset = -v3_distance_above_plane(target_x, target_y, target_z, face.x, face.y, face.z, face.w)
+            / normal_length_squared;
+        scratch_v3_0.set(target_x + face.x * offset, target_y + face.y * offset, target_z + face.z * offset);
+
+        let inside = true;
+        for (j = 0; j < plane_count; j++) {
+            if (j === scratch_outer_planes[candidate]) {
+                // The projection lies on this face; recomputing it can produce roundoff below zero.
+                continue;
+            }
+            const plane = planes[j];
+            if (v3_distance_above_plane(
+                scratch_v3_0.x, scratch_v3_0.y, scratch_v3_0.z,
+                plane.x, plane.y, plane.z, plane.w
+            ) < 0) {
+                inside = false;
+                break;
+            }
+        }
+
+        if (inside) {
+            result.copy(scratch_v3_0);
+            return false;
+        }
+    }
+
+    // If no face projection is feasible, the closest point is on an edge or corner.
+    // At least one active plane was initially violated; clip its intersection lines to the frustum.
+    let best_distance_squared = Infinity;
+    let best_x = 0, best_y = 0, best_z = 0;
+    for (let candidate = 0; candidate < outside_plane_count; candidate++) {
+        const face_index = scratch_outer_planes[candidate];
+        const face = planes[face_index];
+        for (let edge_index = 0; edge_index < plane_count; edge_index++) {
+            if (edge_index === face_index) continue;
+            const edge_plane = planes[edge_index];
+            if (edge_index < face_index && v3_distance_above_plane(
+                target_x, target_y, target_z,
+                edge_plane.x, edge_plane.y, edge_plane.z, edge_plane.w
+            ) < 0) continue;
+            if (!plane3_compute_intersection(
+                scratch_v3_0, scratch_v3_1,
+                face.x, face.y, face.z, face.w,
+                edge_plane.x, edge_plane.y, edge_plane.z, edge_plane.w
+            )) continue;
+
+            const ox = scratch_v3_0.x, oy = scratch_v3_0.y, oz = scratch_v3_0.z;
+            const dx = scratch_v3_1.x, dy = scratch_v3_1.y, dz = scratch_v3_1.z;
+            let lower = -Infinity;
+            let upper = Infinity;
+            for (j = 0; j < plane_count; j++) {
+                if (j === face_index || j === edge_index) continue;
+                const plane = planes[j];
+                const along = plane.x * dx + plane.y * dy + plane.z * dz;
+                const at_origin = v3_distance_above_plane(ox, oy, oz, plane.x, plane.y, plane.z, plane.w);
+                if (along > 0) {
+                    lower = Math.max(lower, -at_origin / along);
+                } else if (along < 0) {
+                    upper = Math.min(upper, -at_origin / along);
+                } else if (at_origin < 0) {
+                    lower = Infinity;
+                    upper = -Infinity;
+                    break;
+                }
+            }
+            if (lower > upper) continue;
+
+            const direction_length_squared = dx * dx + dy * dy + dz * dz;
+            const target_parameter = ((target_x - ox) * dx + (target_y - oy) * dy + (target_z - oz) * dz)
+                / direction_length_squared;
+            const parameter = Math.max(lower, Math.min(upper, target_parameter));
+            const px = ox + dx * parameter, py = oy + dy * parameter, pz = oz + dz * parameter;
+            const tx = px - target_x, ty = py - target_y, tz = pz - target_z;
+            const distance_squared = tx * tx + ty * ty + tz * tz;
+            if (distance_squared < best_distance_squared) {
+                best_distance_squared = distance_squared;
+                best_x = px;
+                best_y = py;
+                best_z = pz;
+            }
+        }
+    }
+    if (best_distance_squared < Infinity) {
+        result.set(best_x, best_y, best_z);
+        return false;
+    }
+
+    // Retain the bounded projection fallback if no usable clipped edge was obtained.
+    let px = target_x;
+    let py = target_y;
+    let pz = target_z;
+
+    for (let iteration = 0; iteration < CLAMP_ITERATION_LIMIT; iteration++) {
+        let worst_plane = -1;
+        let worst_distance = 0;
+
+        for (j = 0; j < plane_count; j++) {
+            const plane = planes[j];
+
+            const distance = v3_distance_above_plane(
+                px, py, pz,
+                plane.x, plane.y, plane.z, plane.w
+            );
+
+            if (distance < worst_distance) {
+                worst_distance = distance;
+                worst_plane = j;
+            }
+        }
+
+        if (worst_plane === -1) {
+            // inside every plane
+            break;
+        }
+
+        const plane = planes[worst_plane];
+
+        plane3_project_point(scratch_v3_0, px, py, pz, plane.x, plane.y, plane.z, plane.w);
+
+        px = scratch_v3_0.x;
+        py = scratch_v3_0.y;
+        pz = scratch_v3_0.z;
+    }
+
+    result.set(px, py, pz);
+
+    return false;
+}

package/src/core/geom/3d/gjk/gjk_epa_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAkkBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;;8BAzdnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,CAAC,YAAY,GAAC,MAAM,EAAE,CAAC,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}
+{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAmkBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;;8BA1dnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,CAAC,YAAY,GAAC,MAAM,EAAE,CAAC,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}

package/src/core/geom/3d/gjk/gjk_epa_penetration.js

@@ -533,9 +533,6 @@ function epa(A, B, out) {
         // Degenerate: no face survived. Report no usable axis (the caller treats a
         // non-positive depth as a miss) rather than reading a stale face and
         // throwing out of the narrowphase step.
-        out[0] = 0;
-        out[1] = 0;
-        out[2] = 0;
         return 0;
     }
 
@@ -545,11 +542,15 @@ function epa(A, B, out) {
             best = f;
         }
     }
+    const depth = FACE_DIST[best];
+    if (!(depth > 0) || !Number.isFinite(depth)) {
+        return 0;
+    }
     const bn = best * 3;
     out[0] = FACE_N[bn];
     out[1] = FACE_N[bn + 1];
     out[2] = FACE_N[bn + 2];
-    return FACE_DIST[best];
+    return depth;
 }
 
 /**

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkFlB"}
+{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAwFlB"}

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js

@@ -26,7 +26,13 @@ export function line3_compute_segment_point_distance_eikonal(
     const ab_z = z1 - z0;
     const L = Math.hypot(ab_x, ab_y, ab_z);
 
-    if (L < 1e-9) return Math.min(d0, d1);
+    if (L < 1e-9) {
+        // A point-like edge still leaves the distance from its endpoints to the target.
+        return Math.min(
+            d0 + Math.hypot(px - x0, py - y0, pz - z0),
+            d1 + Math.hypot(px - x1, py - y1, pz - z1)
+        );
+    }
 
     // Vector AC
     const ac_x = px - x0;
@@ -93,4 +99,4 @@ export function line3_compute_segment_point_distance_eikonal(
         const dist_to_v1 = Math.hypot(px - x1, py - y1, pz - z1);
         return Math.min(d0 + dist_to_v0, d1 + dist_to_v1);
     }
-}
+}

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

@@ -20,4 +20,24 @@
  * @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;
+/**
+ * Ray-triangle intersection with vertices read from a packed triangle,
+ * [ax, ay, az, bx, by, bz, cx, cy, cz] at triangle_offset.
+ *
+ * All nine coordinates are read before validation or output writes so output
+ * callbacks can mutate the source without changing this intersection.
+ * The arithmetic and output order match tri3_ray_intersection.
+ *
+ * @param {import("../SurfacePoint3.js").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 {ArrayLike<number>|number[]|Float32Array|Float64Array} triangle
+ * @param {number} [triangle_offset=0]
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_triangle_array(result: import("../SurfacePoint3.js").SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, triangle: ArrayLike<number> | number[] | Float32Array | Float64Array, triangle_offset?: number): boolean;
 //# sourceMappingURL=tri3_ray_intersection.d.ts.map

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"}
+{"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"}

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

@@ -170,3 +170,185 @@ export function tri3_ray_intersection(
     return true;
 }
 
+
+/**
+ * Ray-triangle intersection with vertices read from a packed triangle,
+ * [ax, ay, az, bx, by, bz, cx, cy, cz] at triangle_offset.
+ *
+ * All nine coordinates are read before validation or output writes so output
+ * callbacks can mutate the source without changing this intersection.
+ * The arithmetic and output order match tri3_ray_intersection.
+ *
+ * @param {import("../SurfacePoint3.js").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 {ArrayLike<number>|number[]|Float32Array|Float64Array} triangle
+ * @param {number} [triangle_offset=0]
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_triangle_array(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    triangle, triangle_offset = 0
+) {
+    const ax = triangle[triangle_offset];
+    const ay = triangle[triangle_offset + 1];
+    const az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3];
+    const by = triangle[triangle_offset + 4];
+    const bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6];
+    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 true;
+}