@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -28,8 +28,8 @@ function build_normalized_morton_2d(
 
     const x0 = data[address];
     const y0 = data[address + 1];
-    const x1 = data[address + 3];
-    const y1 = data[address + 4];
+    const x1 = data[address + 2];
+    const y1 = data[address + 3];
 
     const cx = (x0 + x1) * 0.5;
     const cy = (y0 + y1) * 0.5;
@@ -345,8 +345,9 @@ export class StaticR2Tree {
                     float32, leaf_offset_1
                 );
             } else if (leaf_index_0 < node_count_leaf) {
-                // only left child node is valid
-                array_copy(float32, leaf_offset_0, float32, offset, 6);
+                // only left child node is valid; a 2D box is 4 floats [x0,y0,x1,y1] (copying 6 would spill into
+                // the following node's data)
+                array_copy(float32, leaf_offset_0, float32, offset, 4);
             } else {
                 //initialize to 0-size box same position as previous node
                 copy_box_zero_size(this.__data_float32, offset, (offset - BINARY_NODE_SIZE));

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_detailed_volume_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEAbW,MAAM,EAAE,sBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAEN,MAAM,UADN,MAAM,EAAE,eAER,MAAM,GACJ,MAAM,CAqOlB"}
+{"version":3,"file":"aabb3_detailed_volume_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEAbW,MAAM,EAAE,sBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAEN,MAAM,UADN,MAAM,EAAE,eAER,MAAM,GACJ,MAAM,CAyOlB"}

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

@@ -242,47 +242,51 @@ export function aabb3_detailed_volume_intersection(
         const aabb_plane_nz = scratch_aabb_planes[aabb_plane_address + 2];
         const aabb_plane_constant = scratch_aabb_planes[aabb_plane_address + 3];
 
-        for (let frustum_plane_index = 0; frustum_plane_index < 4; frustum_plane_index++) {
+        // The 4 frustum side-edges are each the intersection of one +/-x plane (index 0 or 1) with one +/-y
+        // plane (index 2 or 3). The previous (i, (i+2)%4) pairing produced only 2 of those 4 edges, each twice
+        // (missing the +x/-y and -x/+y edges), so AABB-vs-edge contact points on those edges were never found.
+        // Enumerate all four non-parallel pairs explicitly.
+        for (let pa = 0; pa < 2; pa++) {
 
-            const plane_bit_mask = 1 << frustum_plane_index;
-
-            if ((plane_mask & plane_bit_mask) === 0) {
-                // non-intersecting plane, ignore
+            if ((plane_mask & (1 << pa)) === 0) {
                 continue;
             }
 
-            const cp_0 = frustum_plane_index * 4;
-
-            const next_orthogonal_plane_index = (frustum_plane_index + 2) % 4;
-            const cp_1 = next_orthogonal_plane_index * 4;
+            const cp_0 = pa * 4;
 
-            const intersection_exists = plane3_compute_convex_3_plane_intersection(
-                scratch_v3_array, 0,
-                aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
-                planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
-                planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
-            );
+            for (let pb = 2; pb < 4; pb++) {
 
-            if (intersection_exists) {
+                if ((plane_mask & (1 << pb)) === 0) {
+                    continue;
+                }
 
-                const intersection_point_x = scratch_v3_array[0];
-                const intersection_point_y = scratch_v3_array[1];
-                const intersection_point_z = scratch_v3_array[2];
+                const cp_1 = pb * 4;
 
-                const point_within_box = !(
-                    (intersection_point_x + EPSILON) < x0 || (intersection_point_x - EPSILON) > x1
-                    || (intersection_point_y + EPSILON) < y0 || (intersection_point_y - EPSILON) > y1
-                    || (intersection_point_z + EPSILON) < z0 || (intersection_point_z - EPSILON) > z1
+                const intersection_exists = plane3_compute_convex_3_plane_intersection(
+                    scratch_v3_array, 0,
+                    aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
+                    planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
+                    planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
                 );
 
-                if (point_within_box) {
-                    // point is within the AABB bounds
+                if (intersection_exists) {
+
+                    const intersection_point_x = scratch_v3_array[0];
+                    const intersection_point_y = scratch_v3_array[1];
+                    const intersection_point_z = scratch_v3_array[2];
 
-                    // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
+                    const point_within_box = !(
+                        (intersection_point_x + EPSILON) < x0 || (intersection_point_x - EPSILON) > x1
+                        || (intersection_point_y + EPSILON) < y0 || (intersection_point_y - EPSILON) > y1
+                        || (intersection_point_z + EPSILON) < z0 || (intersection_point_z - EPSILON) > z1
+                    );
 
-                    destination[destination_cursor++] = intersection_point_x;
-                    destination[destination_cursor++] = intersection_point_y;
-                    destination[destination_cursor++] = intersection_point_z;
+                    if (point_within_box) {
+                        // point is within the AABB bounds
+                        destination[destination_cursor++] = intersection_point_x;
+                        destination[destination_cursor++] = intersection_point_y;
+                        destination[destination_cursor++] = intersection_point_z;
+                    }
                 }
             }
         }

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,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,CAgDlB"}
+{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,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,CAkDlB"}

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

@@ -59,7 +59,9 @@ export function aabb3_near_distance_to_intersection_ray_segment(
     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) {
+    // Negated `<=` so a NaN bound (ray parallel to a slab with the origin exactly on that slab's face) is
+    // treated as a miss; `t_box_min > t_box_max` would be false for NaN and leak NaN out as the result.
+    if (!(t_box_min <= t_box_max)) {
         // signal a miss
         return Infinity;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_signed_distance_to_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_signed_distance_to_aabb3.js"],"names":[],"mappings":"AAAA,+KA2BC"}
+{"version":3,"file":"aabb3_signed_distance_to_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_signed_distance_to_aabb3.js"],"names":[],"mappings":"AAAA,+KA8BC"}

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

@@ -16,13 +16,16 @@ export function aabb3_signed_distance_to_aabb3(
     const dy = Math.max(yp0, yp1);
     const dz = Math.max(zp0, zp1);
 
-    //straight-line distance
-    let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
     if (dx < 0 && dy < 0 && dz < 0) {
-        //penetration
-        return -distance;
-    } else {
-        return distance;
+        //penetration: boxes overlap on every axis
+        return -Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
+
+    // Separated on at least one axis. Only the positive (separating) components contribute to the gap;
+    // a negative component means the boxes already overlap on that axis and must not inflate the distance.
+    const sx = dx > 0 ? dx : 0;
+    const sy = dy > 0 ? dy : 0;
+    const sz = dz > 0 ? dz : 0;
+
+    return Math.sqrt(sx * sx + sy * sy + sz * sz);
 }

package/src/{engine/physics/narrowphase/decomposition/aabb_world_to_local.d.ts → core/geom/3d/aabb/aabb3_transform_oriented_inverse.d.ts}

@@ -1,15 +1,17 @@
 /**
- * Transform a world-space AABB into a body's local frame.
+ * Inverse counterpart of {@link aabb3_transform_oriented}: transform an AABB
+ * through the INVERSE of a rigid transform (position + orientation) — i.e.
+ * re-express a world-space AABB in the local frame of a posed object.
  *
- * Given the body's world transform (pos, rot), computes
+ * Given the pose (pos, rot), computes
  *   p_local = rot⁻¹ · (p_world − pos)
  * for each of the world AABB's 8 corners, then writes the tight bbox
  * over those 8 transformed corners.
  *
- * Used by the concave-shape narrowphase path: a concave collider's
+ * Canonical use (physics narrowphase, concave path): a concave collider's
  * triangle enumerator wants its query AABB in the concave shape's
- * body-local frame, so we project the other collider's *world* AABB
- * through the concave body's inverse pose to get that.
+ * body-local frame, so the other collider's *world* AABB is projected
+ * through the concave body's inverse pose.
  *
  * 8-corner brute force rather than Arvo's element-wise-abs trick:
  *   - The world AABB we start from is *already* a loose envelope (it
@@ -31,5 +33,5 @@
  * @param {number} rot_z
  * @param {number} rot_w
  */
-export function aabb_world_to_local(out: Float64Array, out_offset: number, world_aabb: Float64Array | number[], pos_x: number, pos_y: number, pos_z: number, rot_x: number, rot_y: number, rot_z: number, rot_w: number): void;
-//# sourceMappingURL=aabb_world_to_local.d.ts.map
+export function aabb3_transform_oriented_inverse(out: Float64Array, out_offset: number, world_aabb: Float64Array | number[], pos_x: number, pos_y: number, pos_z: number, rot_x: number, rot_y: number, rot_z: number, rot_w: number): void;
+//# sourceMappingURL=aabb3_transform_oriented_inverse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_transform_oriented_inverse.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,sDAXW,YAAY,cACZ,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAwChB"}

package/src/{engine/physics/narrowphase/decomposition/aabb_world_to_local.js → core/geom/3d/aabb/aabb3_transform_oriented_inverse.js}

@@ -1,4 +1,4 @@
-import { v3_quat3_apply_inverse } from "../../../../core/geom/vec3/v3_quat3_apply_inverse.js";
+import { v3_quat3_apply_inverse } from "../../vec3/v3_quat3_apply_inverse.js";
 
 /**
  * Scratch for the per-corner inverse-rotation output. 3 floats; allocation-free.
@@ -7,17 +7,19 @@ import { v3_quat3_apply_inverse } from "../../../../core/geom/vec3/v3_quat3_appl
 const scratch_local = new Float64Array(3);
 
 /**
- * Transform a world-space AABB into a body's local frame.
+ * Inverse counterpart of {@link aabb3_transform_oriented}: transform an AABB
+ * through the INVERSE of a rigid transform (position + orientation) — i.e.
+ * re-express a world-space AABB in the local frame of a posed object.
  *
- * Given the body's world transform (pos, rot), computes
+ * Given the pose (pos, rot), computes
  *   p_local = rot⁻¹ · (p_world − pos)
  * for each of the world AABB's 8 corners, then writes the tight bbox
  * over those 8 transformed corners.
  *
- * Used by the concave-shape narrowphase path: a concave collider's
+ * Canonical use (physics narrowphase, concave path): a concave collider's
  * triangle enumerator wants its query AABB in the concave shape's
- * body-local frame, so we project the other collider's *world* AABB
- * through the concave body's inverse pose to get that.
+ * body-local frame, so the other collider's *world* AABB is projected
+ * through the concave body's inverse pose.
  *
  * 8-corner brute force rather than Arvo's element-wise-abs trick:
  *   - The world AABB we start from is *already* a loose envelope (it
@@ -39,7 +41,7 @@ const scratch_local = new Float64Array(3);
  * @param {number} rot_z
  * @param {number} rot_w
  */
-export function aabb_world_to_local(
+export function aabb3_transform_oriented_inverse(
     out, out_offset,
     world_aabb,
     pos_x, pos_y, pos_z,

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transformed_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,yDAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,gBACN,MAAM,oBACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CA8ClB"}
+{"version":3,"file":"aabb3_transformed_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,yDAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,gBACN,MAAM,oBACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAmElB"}

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

@@ -1,8 +1,8 @@
 import {v3_distance_above_plane} from "../../vec3/v3_distance_above_plane.js";
 import {aabb3_build_corners} from "./aabb3_build_corners.js";
-import {aabb3_matrix4_project_by_corners} from "./aabb3_matrix4_project_by_corners.js";
 
 const scratch_corners = new Float32Array(24);
+const scratch_transformed = new Float32Array(24);
 
 /**
  * Figure out which side of a plane an Axis-Aligned Bounding Box lies, after applying transform matrix to it
@@ -33,19 +33,40 @@ export function aabb3_transformed_compute_plane_side(
         x0, y0, z0, x1, y1, z1
     );
 
-    aabb3_matrix4_project_by_corners(
-        scratch_corners,
-        scratch_corners,
-        transform_matrix
-    );
+    // Transform all 8 corners by the matrix, keeping each transformed corner. We intentionally do NOT use
+    // aabb3_matrix4_project_by_corners here: it re-bounds the transformed corners down to a single 6-value
+    // AABB written back into the same buffer, which would leave 6 of the 8 classification slots holding stale,
+    // untransformed corners.
+    const m0 = transform_matrix[0], m1 = transform_matrix[1], m2 = transform_matrix[2], m3 = transform_matrix[3];
+    const m4 = transform_matrix[4], m5 = transform_matrix[5], m6 = transform_matrix[6], m7 = transform_matrix[7];
+    const m8 = transform_matrix[8], m9 = transform_matrix[9], m10 = transform_matrix[10], m11 = transform_matrix[11];
+    const m12 = transform_matrix[12], m13 = transform_matrix[13], m14 = transform_matrix[14], m15 = transform_matrix[15];
+
+    for (let i = 0; i < 24; i += 3) {
+        const _x = scratch_corners[i];
+        const _y = scratch_corners[i + 1];
+        const _z = scratch_corners[i + 2];
+
+        const t_x = m0 * _x + m4 * _y + m8 * _z + m12;
+        const t_y = m1 * _x + m5 * _y + m9 * _z + m13;
+        const t_z = m2 * _x + m6 * _y + m10 * _z + m14;
+        const t_w = m3 * _x + m7 * _y + m11 * _z + m15;
+
+        // perspective divide; harmless (w === 1) for the affine model matrices this is called with.
+        const d = 1 / t_w;
+
+        scratch_transformed[i] = t_x * d;
+        scratch_transformed[i + 1] = t_y * d;
+        scratch_transformed[i + 2] = t_z * d;
+    }
 
     let has_above = false, has_below = false;
 
     for (let i = 0; i < 8; i++) {
         const i3 = i * 3;
-        const x = scratch_corners[i3];
-        const y = scratch_corners[i3 + 1];
-        const z = scratch_corners[i3 + 2];
+        const x = scratch_transformed[i3];
+        const y = scratch_transformed[i3 + 1];
+        const z = scratch_transformed[i3 + 2];
 
         if (v3_distance_above_plane(x, y, z, plane_normal_x, plane_normal_y, plane_normal_z, plane_offset)) {
             has_above = true;

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

@@ -1,5 +1,5 @@
-import {min2} from "../../../math/min2.js";
-import {max2} from "../../../math/max2.js";
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
 
 /**
  * Multidimensional axis-aligned bounding box calculation
@@ -27,7 +27,7 @@ export function compute_aabb_from_points(
 
     for (i = 0; i < input_count; i++) {
 
-        const offset_0 = input_count + i * d;
+        const offset_0 = input_offset + i * d;
 
         for (j = 0; j < d; j++) {
             const v = input[offset_0 + j];

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

@@ -0,0 +1,12 @@
+/**
+ * Compute AABB for a group of triangles based on index-buffer
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>} indices
+ * @param {number[]|ArrayLike<number>} positions
+ * @param {number} index_offset
+ * @param {number} index_count
+ * @param {number} dimension_count
+ */
+export function compute_triangle_group_aabb3(output: number[] | Float32Array, output_offset: number, indices: number[] | ArrayLike<number>, positions: number[] | ArrayLike<number>, index_offset: number, index_count: number, dimension_count: number): void;
+//# sourceMappingURL=compute_triangle_group_aabb3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compute_triangle_group_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/compute_triangle_group_aabb3.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qDARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,aAC1B,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,eACN,MAAM,mBACN,MAAM,QAkChB"}

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

@@ -0,0 +1,46 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ * Compute AABB for a group of triangles based on index-buffer
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>} indices
+ * @param {number[]|ArrayLike<number>} positions
+ * @param {number} index_offset
+ * @param {number} index_count
+ * @param {number} dimension_count
+ */
+export function compute_triangle_group_aabb3(
+    output,
+    output_offset,
+    indices,
+    positions,
+    index_offset,
+    index_count,
+    dimension_count
+) {
+
+    let i = 0;
+    for (; i < dimension_count; i++) {
+        // min bound
+        output[output_offset + i] = Infinity;
+        // max bound
+        output[output_offset + i + dimension_count] = -Infinity;
+    }
+
+    for (i = 0; i < index_count; i++) {
+        for (let j = 0; j < 3; j++) {
+            const index = indices[index_offset + i * 3 + j];
+
+            const i3 = index * dimension_count;
+
+            for (let k = 0; k < dimension_count; k++) {
+                const v = positions[i3 + k];
+
+                output[output_offset + k] = min2(output[output_offset + k], v);
+                output[output_offset + k + dimension_count] = max2(output[output_offset + k + dimension_count], v);
+            }
+        }
+    }
+}

package/src/core/geom/3d/box/box3_projected_half_extent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Half-extent ("radius") of an oriented box projected onto a unit world
+ * axis `(ux, uy, uz)`: `Σ |axisᵢ · u| · hᵢ` over the box's three world-space
+ * basis vectors. The SAT interval of the box on `u` is
+ * `[centre·u − r, centre·u + r]`.
+ *
+ * `axes` holds the box's world basis as 9 floats (row-major: x-axis,
+ * y-axis, z-axis) starting at `off` — callers with one box pass 0;
+ * callers packing several bases into one scratch array pass the offset.
+ *
+ * Shared by the box-box and box-triangle SAT sources, which previously
+ * each carried a byte-identical copy.
+ *
+ * @param {Float64Array|number[]} axes
+ * @param {number} off
+ * @param {number} hx
+ * @param {number} hy
+ * @param {number} hz box half-extents
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz unit projection axis (world)
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_projected_half_extent(axes: Float64Array | number[], off: number, hx: number, hy: number, hz: number, ux: number, uy: number, uz: number): number;
+//# sourceMappingURL=box3_projected_half_extent.d.ts.map

package/src/core/geom/3d/box/box3_projected_half_extent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box3_projected_half_extent.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/box/box3_projected_half_extent.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iDAbW,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/geom/3d/box/box3_projected_half_extent.js

@@ -0,0 +1,35 @@
+/**
+ * Half-extent ("radius") of an oriented box projected onto a unit world
+ * axis `(ux, uy, uz)`: `Σ |axisᵢ · u| · hᵢ` over the box's three world-space
+ * basis vectors. The SAT interval of the box on `u` is
+ * `[centre·u − r, centre·u + r]`.
+ *
+ * `axes` holds the box's world basis as 9 floats (row-major: x-axis,
+ * y-axis, z-axis) starting at `off` — callers with one box pass 0;
+ * callers packing several bases into one scratch array pass the offset.
+ *
+ * Shared by the box-box and box-triangle SAT sources, which previously
+ * each carried a byte-identical copy.
+ *
+ * @param {Float64Array|number[]} axes
+ * @param {number} off
+ * @param {number} hx
+ * @param {number} hy
+ * @param {number} hz box half-extents
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz unit projection axis (world)
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_projected_half_extent(axes, off, hx, hy, hz, ux, uy, uz) {
+    const px = ux * axes[off] + uy * axes[off + 1] + uz * axes[off + 2];
+    const py = ux * axes[off + 3] + uy * axes[off + 4] + uz * axes[off + 5];
+    const pz = ux * axes[off + 6] + uy * axes[off + 7] + uz * axes[off + 8];
+
+    return (px < 0 ? -px : px) * hx
+        + (py < 0 ? -py : py) * hy
+        + (pz < 0 ? -pz : pz) * hz;
+}

package/src/core/geom/3d/box/box3_raycast.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Ray ↔ box intersection in the box's LOCAL frame: an axis-aligned box centred
+ * at the origin spanning `[−hx,hx] × [−hy,hy] × [−hz,hz]` — the canonical pose of
+ * `BoxShape3D` (an oriented box transformed into its own frame). Slab method.
+ * Returns the hit distance `t` and writes the outward unit FACE normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first crossing at or after the origin within `tMax` is returned; a ray
+ *    starting INSIDE the box returns its exit face;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * returns a boolean + hit POSITION + a quantized normal. This one serves the
+ * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
+ * clamping, and origin-inside handling.
+ *
+ * @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
+ * @param {number} hx half-extent along x
+ * @param {number} hy half-extent along y
+ * @param {number} hz half-extent along z
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, hx: number, hy: number, hz: number): number;
+//# sourceMappingURL=box3_raycast.d.ts.map

package/src/core/geom/3d/box/box3_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box3_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/box/box3_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wCAjBW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkDlB"}

package/src/core/geom/3d/box/box3_raycast.js

@@ -0,0 +1,81 @@
+/**
+ * Ray ↔ box intersection in the box's LOCAL frame: an axis-aligned box centred
+ * at the origin spanning `[−hx,hx] × [−hy,hy] × [−hz,hz]` — the canonical pose of
+ * `BoxShape3D` (an oriented box transformed into its own frame). Slab method.
+ * Returns the hit distance `t` and writes the outward unit FACE normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first crossing at or after the origin within `tMax` is returned; a ray
+ *    starting INSIDE the box returns its exit face;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * returns a boolean + hit POSITION + a quantized normal. This one serves the
+ * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
+ * clamping, and origin-inside handling.
+ *
+ * @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
+ * @param {number} hx half-extent along x
+ * @param {number} hy half-extent along y
+ * @param {number} hz half-extent along z
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function box3_raycast(outNormal, outOffset, ox, oy, oz, dx, dy, dz, tMax, hx, hy, hz) {
+    let tmin = -Infinity, tmax = Infinity;
+    let enterAxis = 0, enterSign = 0, exitAxis = 0, exitSign = 0;
+
+    // X slab.
+    if (dx !== 0) {
+        const inv = 1 / dx;
+        let tn = (-hx - ox) * inv, tf = (hx - ox) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 0; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 0; exitSign = -nsign; }
+    } else if (ox < -hx || ox > hx) {
+        return Infinity;
+    }
+    // Y slab.
+    if (dy !== 0) {
+        const inv = 1 / dy;
+        let tn = (-hy - oy) * inv, tf = (hy - oy) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 1; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 1; exitSign = -nsign; }
+    } else if (oy < -hy || oy > hy) {
+        return Infinity;
+    }
+    // Z slab.
+    if (dz !== 0) {
+        const inv = 1 / dz;
+        let tn = (-hz - oz) * inv, tf = (hz - oz) * inv, nsign = -1;
+        if (tn > tf) { const tmp = tn; tn = tf; tf = tmp; nsign = 1; }
+        if (tn > tmin) { tmin = tn; enterAxis = 2; enterSign = nsign; }
+        if (tf < tmax) { tmax = tf; exitAxis = 2; exitSign = -nsign; }
+    } else if (oz < -hz || oz > hz) {
+        return Infinity;
+    }
+
+    if (tmax < tmin || tmax < 0) return Infinity;
+
+    let t, axis, sign;
+    if (tmin >= 0) { t = tmin; axis = enterAxis; sign = enterSign; }
+    else { t = tmax; axis = exitAxis; sign = exitSign; } // origin inside the box
+
+    if (t > tMax) return Infinity;
+    outNormal[outOffset] = 0; outNormal[outOffset + 1] = 0; outNormal[outOffset + 2] = 0;
+    outNormal[outOffset + axis] = sign;
+    return t;
+}

package/src/core/geom/3d/capsule/capsule_raycast.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Ray ↔ capsule intersection in the capsule's LOCAL frame: a capsule along the
+ * local Y axis — a cylinder of radius `r` over `y ∈ [−hh, hh]` capped by
+ * hemispheres of radius `r` at `(0, ±hh, 0)` — the canonical pose of
+ * `CapsuleShape3D` (`hh = height / 2`). Tests the infinite cylinder (clamped to
+ * the segment) and the two cap spheres, taking the nearest valid crossing.
+ * Returns the hit distance `t` and writes the outward unit surface normal into
+ * `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link sphere_raycast} / {@link box3_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;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * No prior ray-vs-capsule primitive existed in `core/geom`; this fills that gap
+ * (useful for picking, sensors, and the raycast narrowphase).
+ *
+ * @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
+ * @param {number} r capsule radius
+ * @param {number} hh half-height of the cylindrical section (`height / 2`)
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function capsule_raycast(outNormal: Float64Array | number[], outOffset: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, r: number, hh: number): number;
+//# sourceMappingURL=capsule_raycast.d.ts.map

package/src/core/geom/3d/capsule/capsule_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/capsule/capsule_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,2CAhBW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,KACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgElB"}