@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.d.ts

@@ -1,15 +1,7 @@
 /**
- *
- * @param {number[]|ArrayLike<number>} result
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} r_x
- * @param {number} r_y
- * @param {number} r_z
+ * @deprecated Renamed to {@link aabb3_closest_point_on_surface}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function aabb3_nearest_point_on_surface(result: number[] | ArrayLike<number>, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, r_x: number, r_y: number, r_z: number): void;
+export const aabb3_nearest_point_on_surface: typeof aabb3_closest_point_on_surface;
+import { aabb3_closest_point_on_surface } from "./aabb3_closest_point_on_surface.js";
 //# sourceMappingURL=aabb3_nearest_point_on_surface.d.ts.map

package/src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_nearest_point_on_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,uDAXW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}
+{"version":3,"file":"aabb3_nearest_point_on_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,mFAA6E;+CAN9B,qCAAqC"}

package/src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.js

@@ -1,57 +1,7 @@
-import { clamp } from "../../../math/clamp.js";
-import { min2 } from "../../../math/min2.js";
+import { aabb3_closest_point_on_surface } from "./aabb3_closest_point_on_surface.js";
 
 /**
- *
- * @param {number[]|ArrayLike<number>} result
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} r_x
- * @param {number} r_y
- * @param {number} r_z
+ * @deprecated Renamed to {@link aabb3_closest_point_on_surface}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function aabb3_nearest_point_on_surface(result, x0, y0, z0, x1, y1, z1, r_x, r_y, r_z) {
-    // clamp the reference to the box; for exterior points this is already the nearest surface point
-    const cx = clamp(r_x, x0, x1);
-    const cy = clamp(r_y, y0, y1);
-    const cz = clamp(r_z, z0, z1);
-
-    const inside = (cx === r_x) && (cy === r_y) && (cz === r_z);
-
-    if (!inside) {
-        result[0] = cx;
-        result[1] = cy;
-        result[2] = cz;
-        return;
-    }
-
-    // interior point: snap to the nearest face
-    const dx0 = r_x - x0;
-    const dx1 = x1 - r_x;
-    const dy0 = r_y - y0;
-    const dy1 = y1 - r_y;
-    const dz0 = r_z - z0;
-    const dz1 = z1 - r_z;
-
-    const dx = min2(dx0, dx1);
-    const dy = min2(dy0, dy1);
-    const dz = min2(dz0, dz1);
-
-    if (dx <= dy && dx <= dz) {
-        result[0] = (dx0 <= dx1) ? x0 : x1;
-        result[1] = r_y;
-        result[2] = r_z;
-    } else if (dy <= dz) {
-        result[0] = r_x;
-        result[1] = (dy0 <= dy1) ? y0 : y1;
-        result[2] = r_z;
-    } else {
-        result[0] = r_x;
-        result[1] = r_y;
-        result[2] = (dz0 <= dz1) ? z0 : z1;
-    }
-}
+export const aabb3_nearest_point_on_surface = aabb3_closest_point_on_surface;

package/src/core/geom/3d/aabb/aabb3_projected_area.d.ts

@@ -0,0 +1,9 @@
+/**
+ * NOTE: Consider using an optimized aabb projection method based on Jim Arvo's Graphics Gems algorithm: https://stackoverflow.com/a/58630206/3973586
+ * Almost everything is inlined for speed
+ * @param {number[]} aabb_corners
+ * @param {number[]|mat4|Float32Array} projection_matrix
+ * @returns {number}
+ */
+export function aabb3_projected_area(aabb_corners: number[], projection_matrix: number[] | mat4 | Float32Array): number;
+//# sourceMappingURL=aabb3_projected_area.d.ts.map

package/src/core/geom/3d/aabb/aabb3_projected_area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_projected_area.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_projected_area.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,mDAJW,MAAM,EAAE,qBACR,MAAM,EAAE,UAAM,YAAY,GACxB,MAAM,CAqElB"}

package/src/core/geom/3d/aabb/aabb3_projected_area.js

@@ -0,0 +1,86 @@
+/*
+
+    one option of Algorithm (problem-orthogonal only, rectangles under perspective projection do not behave this way):
+    - compute normal vectors for each face
+    - transform normal vectors
+    - if vector is pointing away from the viewer - ignore it
+    - compute rectangular area of the related face
+    - sum up
+ */
+
+
+/**
+ * NOTE: Consider using an optimized aabb projection method based on Jim Arvo's Graphics Gems algorithm: https://stackoverflow.com/a/58630206/3973586
+ * Almost everything is inlined for speed
+ * @param {number[]} aabb_corners
+ * @param {number[]|mat4|Float32Array} projection_matrix
+ * @returns {number}
+ */
+export function aabb3_projected_area(aabb_corners, projection_matrix) {
+
+    // read matrix into local variables for speed
+    const a0 = projection_matrix[0];
+    const a1 = projection_matrix[1];
+    const a3 = projection_matrix[3];
+
+    const b0 = projection_matrix[4];
+    const b1 = projection_matrix[5];
+    const b3 = projection_matrix[7];
+
+    const c0 = projection_matrix[8];
+    const c1 = projection_matrix[9];
+    const c3 = projection_matrix[11];
+
+    const d0 = projection_matrix[12];
+    const d1 = projection_matrix[13];
+    const d3 = projection_matrix[15];
+
+    // initialize bounds
+    let x0 = Number.POSITIVE_INFINITY;
+    let y0 = Number.POSITIVE_INFINITY;
+
+    let x1 = Number.NEGATIVE_INFINITY;
+    let y1 = Number.NEGATIVE_INFINITY;
+
+
+    for (let i = 0; i < 24; i += 3) {
+
+        // read corner
+        const _x = aabb_corners[i];
+        const _y = aabb_corners[i + 1];
+        const _z = aabb_corners[i + 2];
+
+        // apply transform
+        const t_x = a0 * _x + b0 * _y + c0 * _z + d0;
+        const t_y = a1 * _x + b1 * _y + c1 * _z + d1;
+        const t_w = a3 * _x + b3 * _y + c3 * _z + d3;
+
+        // perspective divide and normalization (-1,1 space projected to -0.5,0.5)
+        const d = 0.5 / t_w;
+
+        // finally compute screen-space coordinates of the corner
+        const x = t_x * d;
+        const y = t_y * d;
+
+        if (x0 > x) {
+            x0 = x;
+        }
+
+        if (x1 < x) {
+            x1 = x;
+        }
+
+        if (y0 > y) {
+            y0 = y;
+        }
+        if (y1 < y) {
+            y1 = y;
+        }
+
+    }
+
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+
+    return dx * dy;
+}

package/src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Conservative slab query returning the near (entry) `t` at which an axis-aligned ray SEGMENT first meets a
+ * closed AABB (faces included), or `Infinity` when the segment misses. Built for BROADPHASE use: callers
+ * prune a subtree whenever this reports a miss, so a false miss silently drops geometry the ray crosses.
+ *
+ * This is the distance-reporting companion of the boolean {@link aabb3_intersects_ray_segment}: the two
+ * answer the same containment question and MUST agree on every input — a segment the boolean test accepts
+ * returns a finite entry distance here, never the miss sentinel.
+ *
+ * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
+ * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
+ * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
+ * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
+ * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
+ * +Infinity]`, imposing no constraint, and the ray is inside the box from `min_distance` onward: the correct
+ * entry distance is `t_box_min` (typically `min_distance`). Treating the NaN as a miss instead — the
+ * historical behaviour — is a false negative that drops a box the ray genuinely grazes, exactly the
+ * broadphase failure {@link aabb3_intersects_ray_segment} was hardened against.
+ *
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number} the near entry distance, or `Infinity` when the segment misses the box
+ */
+export function aabb3_ray_segment_entry_distance(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, inv_direction_x: number, inv_direction_y: number, inv_direction_z: number, min_distance: number, max_distance: number): number;
+//# sourceMappingURL=aabb3_ray_segment_entry_distance.d.ts.map

package/src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_ray_segment_entry_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qDAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAyDlB"}

package/src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js

@@ -0,0 +1,95 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ * Conservative slab query returning the near (entry) `t` at which an axis-aligned ray SEGMENT first meets a
+ * closed AABB (faces included), or `Infinity` when the segment misses. Built for BROADPHASE use: callers
+ * prune a subtree whenever this reports a miss, so a false miss silently drops geometry the ray crosses.
+ *
+ * This is the distance-reporting companion of the boolean {@link aabb3_intersects_ray_segment}: the two
+ * answer the same containment question and MUST agree on every input — a segment the boolean test accepts
+ * returns a finite entry distance here, never the miss sentinel.
+ *
+ * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
+ * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
+ * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
+ * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
+ * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
+ * +Infinity]`, imposing no constraint, and the ray is inside the box from `min_distance` onward: the correct
+ * entry distance is `t_box_min` (typically `min_distance`). Treating the NaN as a miss instead — the
+ * historical behaviour — is a false negative that drops a box the ray genuinely grazes, exactly the
+ * broadphase failure {@link aabb3_intersects_ray_segment} was hardened against.
+ *
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number} the near entry distance, or `Infinity` when the segment misses the box
+ */
+export function aabb3_ray_segment_entry_distance(
+    x0, y0, z0,
+    x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    inv_direction_x, inv_direction_y, inv_direction_z,
+    min_distance, max_distance
+) {
+
+    // move aabb into ray space
+    const _x0 = x0 - origin_x;
+    const _y0 = y0 - origin_y;
+    const _z0 = z0 - origin_z;
+
+    const _x1 = x1 - origin_x;
+    const _y1 = y1 - origin_y;
+    const _z1 = z1 - origin_z;
+
+
+    // Absolute distances to lower and upper box coordinates
+    const t_lower_x = _x0 * inv_direction_x;
+    const t_lower_y = _y0 * inv_direction_y;
+    const t_lower_z = _z0 * inv_direction_z;
+
+    const t_upper_x = _x1 * inv_direction_x;
+    const t_upper_y = _y1 * inv_direction_y;
+    const t_upper_z = _z1 * inv_direction_z;
+
+    // A NaN slab coordinate (`0 · ±Infinity`) flags an axis-aligned ray whose origin lies exactly on one
+    // of this slab's faces: it is parallel to the slab and, because the closed box owns its faces, stays
+    // inside it for every t. Such an axis contributes the fully-open interval [-Infinity, +Infinity]; see
+    // the function doc for why letting the raw NaN flow through min/max would instead poison the test into
+    // a false miss.
+    const x_parallel_on_face = t_lower_x !== t_lower_x || t_upper_x !== t_upper_x;
+    const y_parallel_on_face = t_lower_y !== t_lower_y || t_upper_y !== t_upper_y;
+    const z_parallel_on_face = t_lower_z !== t_lower_z || t_upper_z !== t_upper_z;
+
+    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
+    const t_min_x = x_parallel_on_face ? -Infinity : min2(t_lower_x, t_upper_x);
+    const t_min_y = y_parallel_on_face ? -Infinity : min2(t_lower_y, t_upper_y);
+    const t_min_z = z_parallel_on_face ? -Infinity : min2(t_lower_z, t_upper_z);
+
+    const t_max_x = x_parallel_on_face ? Infinity : max2(t_lower_x, t_upper_x);
+    const t_max_y = y_parallel_on_face ? Infinity : max2(t_lower_y, t_upper_y);
+    const t_max_z = z_parallel_on_face ? Infinity : max2(t_lower_z, t_upper_z);
+
+    // Easy to remember: ``max of mins, and min of maxes''
+    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
+    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
+
+    if (t_box_min > t_box_max) {
+        // signal a miss
+        return Infinity;
+    }
+
+    return t_box_min;
+}

package/src/core/geom/3d/aabb/aabb3_raycast.d.ts

@@ -1,25 +1,7 @@
 /**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} result hit 6-tuple is written here as follows: [hit_position_x, hit_position_y, hit_position_z, hit_normal_x, hit_normal_y, hit_normal_z]
- * @param {number} result_offset offset into result array where to write the hit data
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} origin_x ray origin
- * @param {number} origin_y ray origin
- * @param {number} origin_z ray origin
- * @param {number} direction_x ray direction
- * @param {number} direction_y ray direction
- * @param {number} direction_z ray direction
- * @returns {boolean} true if ray hit the box, false otherwise
- *
- *
- * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
- * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
- * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
+ * @deprecated Renamed to {@link aabb3_raycast_hit_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function aabb3_raycast(result: number[] | ArrayLike<number> | Float32Array, result_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+export const aabb3_raycast: typeof aabb3_raycast_hit_point;
+import { aabb3_raycast_hit_point } from "./aabb3_raycast_hit_point.js";
 //# sourceMappingURL=aabb3_raycast.d.ts.map

package/src/core/geom/3d/aabb/aabb3_raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_raycast.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,sCArBW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAqFnB"}
+{"version":3,"file":"aabb3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_raycast.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,2DAAqD;wCANb,8BAA8B"}

package/src/core/geom/3d/aabb/aabb3_raycast.js

@@ -1,109 +1,7 @@
-//
-
-
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
-import { v3_length } from "../../vec3/v3_length.js";
-
-/**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} result hit 6-tuple is written here as follows: [hit_position_x, hit_position_y, hit_position_z, hit_normal_x, hit_normal_y, hit_normal_z]
- * @param {number} result_offset offset into result array where to write the hit data
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} origin_x ray origin
- * @param {number} origin_y ray origin
- * @param {number} origin_z ray origin
- * @param {number} direction_x ray direction
- * @param {number} direction_y ray direction
- * @param {number} direction_z ray direction
- * @returns {boolean} true if ray hit the box, false otherwise
- *
- *
- * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
- * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
- * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
- */
-export function aabb3_raycast(
-    result, result_offset,
-    x0, y0, z0, x1, y1, z1,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z
-) {
-
-    // first find intersection
-    const dir_inv_x = 1 / direction_x;
-    const dir_inv_y = 1 / direction_y;
-    const dir_inv_z = 1 / direction_z;
-
-    const t1_x = (x0 - origin_x) * dir_inv_x;
-    const t2_x = (x1 - origin_x) * dir_inv_x;
-
-    const t1_y = (y0 - origin_y) * dir_inv_y;
-    const t2_y = (y1 - origin_y) * dir_inv_y;
-
-    const t1_z = (z0 - origin_z) * dir_inv_z;
-    const t2_z = (z1 - origin_z) * dir_inv_z;
-
-    let tMax = max2(t1_x, t2_x);
-    tMax = min2(tMax, max2(t1_y, t2_y));
-    tMax = min2(tMax, max2(t1_z, t2_z));
-
-    if (tMax < 0) {
-        // if tMax < 0, AABB is behind the ray origin in the opposite direction to the ray's
-        return false;
-    }
-
-    let tMin = min2(t1_x, t2_x);
-    tMin = max2(tMin, min2(t1_y, t2_y));
-    tMin = max2(tMin, min2(t1_z, t2_z));
-
-    if (tMin > tMax) {
-        // if tMin > tMax, ray does not intersect the AABB
-        return false;
-    }
-
-    // ray hit detected, figure out offset along the ray from origin to hit
-    const ray_offset = tMin < 0 ? tMax : tMin;
-
-    const hit_x = origin_x + direction_x * ray_offset;
-    const hit_y = origin_y + direction_y * ray_offset;
-    const hit_z = origin_z + direction_z * ray_offset;
-
-    // figure out normal
-    const center_x = (x0 + x1) * 0.5;
-    const center_y = (y0 + y1) * 0.5;
-    const center_z = (z0 + z1) * 0.5;
-
-    const p_x = hit_x - center_x;
-    const p_y = hit_y - center_y;
-    const p_z = hit_z - center_z;
-
-    const d_x = (x0 - x1) * 0.5;
-    const d_y = (y0 - y1) * 0.5;
-    const d_z = (z0 - z1) * 0.5;
-
-    // bias is necessary to deal with rounding errors
-    const bias = 1.000001;
-
-    const normal_x = (p_x / Math.abs(d_x) * bias) | 0;
-    const normal_y = (p_y / Math.abs(d_y) * bias) | 0;
-    const normal_z = (p_z / Math.abs(d_z) * bias) | 0;
-
-    // normalize surface normal vector
-    const normal_inv_length = 1 / v3_length(normal_x, normal_y, normal_z);
-
-    result[result_offset] = hit_x;
-    result[result_offset + 1] = hit_y;
-    result[result_offset + 2] = hit_z;
-
-    result[result_offset + 3] = normal_x * normal_inv_length;
-    result[result_offset + 4] = normal_y * normal_inv_length;
-    result[result_offset + 5] = normal_z * normal_inv_length;
-
-    return true;
-}
+import { aabb3_raycast_hit_point } from "./aabb3_raycast_hit_point.js";
+
+/**
+ * @deprecated Renamed to {@link aabb3_raycast_hit_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const aabb3_raycast = aabb3_raycast_hit_point;

package/src/core/geom/3d/aabb/aabb3_raycast_hit_point.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} result hit 6-tuple is written here as follows: [hit_position_x, hit_position_y, hit_position_z, hit_normal_x, hit_normal_y, hit_normal_z]
+ * @param {number} result_offset offset into result array where to write the hit data
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x ray origin
+ * @param {number} origin_y ray origin
+ * @param {number} origin_z ray origin
+ * @param {number} direction_x ray direction
+ * @param {number} direction_y ray direction
+ * @param {number} direction_z ray direction
+ * @returns {boolean} true if ray hit the box, false otherwise
+ *
+ *
+ * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
+ * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
+ * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
+ */
+export function aabb3_raycast_hit_point(result: number[] | ArrayLike<number> | Float32Array, result_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+//# sourceMappingURL=aabb3_raycast_hit_point.d.ts.map

package/src/core/geom/3d/aabb/aabb3_raycast_hit_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_raycast_hit_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_raycast_hit_point.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gDArBW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAqFnB"}

package/src/core/geom/3d/aabb/aabb3_raycast_hit_point.js

@@ -0,0 +1,109 @@
+//
+
+
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import { v3_length } from "../../vec3/v3_length.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} result hit 6-tuple is written here as follows: [hit_position_x, hit_position_y, hit_position_z, hit_normal_x, hit_normal_y, hit_normal_z]
+ * @param {number} result_offset offset into result array where to write the hit data
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x ray origin
+ * @param {number} origin_y ray origin
+ * @param {number} origin_z ray origin
+ * @param {number} direction_x ray direction
+ * @param {number} direction_y ray direction
+ * @param {number} direction_z ray direction
+ * @returns {boolean} true if ray hit the box, false otherwise
+ *
+ *
+ * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
+ * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
+ * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
+ */
+export function aabb3_raycast_hit_point(
+    result, result_offset,
+    x0, y0, z0, x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+
+    // first find intersection
+    const dir_inv_x = 1 / direction_x;
+    const dir_inv_y = 1 / direction_y;
+    const dir_inv_z = 1 / direction_z;
+
+    const t1_x = (x0 - origin_x) * dir_inv_x;
+    const t2_x = (x1 - origin_x) * dir_inv_x;
+
+    const t1_y = (y0 - origin_y) * dir_inv_y;
+    const t2_y = (y1 - origin_y) * dir_inv_y;
+
+    const t1_z = (z0 - origin_z) * dir_inv_z;
+    const t2_z = (z1 - origin_z) * dir_inv_z;
+
+    let tMax = max2(t1_x, t2_x);
+    tMax = min2(tMax, max2(t1_y, t2_y));
+    tMax = min2(tMax, max2(t1_z, t2_z));
+
+    if (tMax < 0) {
+        // if tMax < 0, AABB is behind the ray origin in the opposite direction to the ray's
+        return false;
+    }
+
+    let tMin = min2(t1_x, t2_x);
+    tMin = max2(tMin, min2(t1_y, t2_y));
+    tMin = max2(tMin, min2(t1_z, t2_z));
+
+    if (tMin > tMax) {
+        // if tMin > tMax, ray does not intersect the AABB
+        return false;
+    }
+
+    // ray hit detected, figure out offset along the ray from origin to hit
+    const ray_offset = tMin < 0 ? tMax : tMin;
+
+    const hit_x = origin_x + direction_x * ray_offset;
+    const hit_y = origin_y + direction_y * ray_offset;
+    const hit_z = origin_z + direction_z * ray_offset;
+
+    // figure out normal
+    const center_x = (x0 + x1) * 0.5;
+    const center_y = (y0 + y1) * 0.5;
+    const center_z = (z0 + z1) * 0.5;
+
+    const p_x = hit_x - center_x;
+    const p_y = hit_y - center_y;
+    const p_z = hit_z - center_z;
+
+    const d_x = (x0 - x1) * 0.5;
+    const d_y = (y0 - y1) * 0.5;
+    const d_z = (z0 - z1) * 0.5;
+
+    // bias is necessary to deal with rounding errors
+    const bias = 1.000001;
+
+    const normal_x = (p_x / Math.abs(d_x) * bias) | 0;
+    const normal_y = (p_y / Math.abs(d_y) * bias) | 0;
+    const normal_z = (p_z / Math.abs(d_z) * bias) | 0;
+
+    // normalize surface normal vector
+    const normal_inv_length = 1 / v3_length(normal_x, normal_y, normal_z);
+
+    result[result_offset] = hit_x;
+    result[result_offset + 1] = hit_y;
+    result[result_offset + 2] = hit_z;
+
+    result[result_offset + 3] = normal_x * normal_inv_length;
+    result[result_offset + 4] = normal_y * normal_inv_length;
+    result[result_offset + 5] = normal_z * normal_inv_length;
+
+    return true;
+}

package/src/core/geom/3d/aabb/aabb3_score_boxes_SAH.js

@@ -1,4 +1,4 @@
-import {aabb3_compute_half_surface_area} from "./aabb3_compute_half_surface_area.js";
+import { aabb3_half_surface_area_extents } from "./aabb3_half_surface_area_extents.js";
 
 /**
  * Compute surface area for a box contain both inputs
@@ -36,7 +36,7 @@ function aabb3_score_boxes_SAH(a, b) {
 
     //
 
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+    return aabb3_half_surface_area_extents(x0, y0, z0, x1, y1, z1);
 }
 
 export {aabb3_score_boxes_SAH};

package/src/core/geom/3d/aabb/aabb3_score_boxes_SAH_delta.d.ts

@@ -1,2 +1,8 @@
-export {};
+/**
+ *
+ * @param {AABB3} b0
+ * @param {AABB3} b1
+ * @return {number}
+ */
+export function aabb3_score_boxes_SAH_delta(b0: AABB3, b1: AABB3): number;
 //# sourceMappingURL=aabb3_score_boxes_SAH_delta.d.ts.map

package/src/core/geom/3d/aabb/aabb3_score_boxes_SAH_delta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_score_boxes_SAH_delta.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_score_boxes_SAH_delta.js"],"names":[],"mappings":""}
+{"version":3,"file":"aabb3_score_boxes_SAH_delta.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_score_boxes_SAH_delta.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,mEAFY,MAAM,CAiCjB"}