@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.d.ts

@@ -1,16 +1,7 @@
 /**
- *
- * @param {Vector3} 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 {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
+ * @deprecated Renamed to {@link ray3_compute_closest_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function ray3_compute_nearest_point_to_point(result: Vector3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, px: number, py: number, pz: number): number;
+export const ray3_compute_nearest_point_to_point: typeof ray3_compute_closest_point;
+import { ray3_compute_closest_point } from "./ray3_compute_closest_point.js";
 //# sourceMappingURL=ray3_compute_nearest_point_to_point.d.ts.map

package/src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,+EAXW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA4BlB"}
+{"version":3,"file":"ray3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oFAA8E;2CANnC,iCAAiC"}

package/src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.js

@@ -1,43 +1,7 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-
-/**
- *
- * @param {Vector3} 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 {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
- */
-export function ray3_compute_nearest_point_to_point(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    px, py, pz
-) {
-
-    // find the closest point
-    const sp0_x = px - origin_x;
-    const sp0_y = py - origin_y;
-    const sp0_z = pz - origin_z;
-
-    //
-    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
-    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
-
-    const t = d3 / d2;
-
-    // compute point on the ray
-    const lp_x = direction_x * t + origin_x;
-    const lp_y = direction_y * t + origin_y;
-    const lp_z = direction_z * t + origin_z;
-
-    result.set(lp_x, lp_y, lp_z);
-
-    return t;
-}
+import { ray3_compute_closest_point } from "./ray3_compute_closest_point.js";
+
+/**
+ * @deprecated Renamed to {@link ray3_compute_closest_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const ray3_compute_nearest_point_to_point = ray3_compute_closest_point;

package/src/core/geom/3d/ray/ray3_compute_point_projection_t.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @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 {number} ref_x
+ * @param {number} ref_y
+ * @param {number} ref_z
+ * @return {number}
+ */
+export function ray3_compute_point_projection_t(origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ref_x: number, ref_y: number, ref_z: number): number;
+//# sourceMappingURL=ray3_compute_point_projection_t.d.ts.map

package/src/core/geom/3d/ray/ray3_compute_point_projection_t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray3_compute_point_projection_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_compute_point_projection_t.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,0DAXW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACL,MAAM,CAiBjB"}

package/src/core/geom/3d/ray/ray3_compute_point_projection_t.js

@@ -0,0 +1,31 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @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 {number} ref_x
+ * @param {number} ref_y
+ * @param {number} ref_z
+ * @return {number}
+ */
+export function ray3_compute_point_projection_t(
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ref_x, ref_y, ref_z
+) {
+    // find the closest point
+    const sp0_x = ref_x - origin_x;
+    const sp0_y = ref_y - origin_y;
+    const sp0_z = ref_z - origin_z;
+
+    //
+    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
+    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
+
+    return d3 / d2;
+}

package/src/core/geom/3d/ray/ray3_distance_to_point.d.ts

@@ -1,15 +1,7 @@
 /**
- *
- * @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 {number} ref_x
- * @param {number} ref_y
- * @param {number} ref_z
- * @return {number}
+ * @deprecated Renamed to {@link ray3_compute_point_projection_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function ray3_distance_to_point(origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ref_x: number, ref_y: number, ref_z: number): number;
+export const ray3_distance_to_point: typeof ray3_compute_point_projection_t;
+import { ray3_compute_point_projection_t } from "./ray3_compute_point_projection_t.js";
 //# sourceMappingURL=ray3_distance_to_point.d.ts.map

package/src/core/geom/3d/ray/ray3_distance_to_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray3_distance_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_distance_to_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,iDAXW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACL,MAAM,CAiBjB"}
+{"version":3,"file":"ray3_distance_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_distance_to_point.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,4EAAsE;gDANtB,sCAAsC"}

package/src/core/geom/3d/ray/ray3_distance_to_point.js

@@ -1,31 +1,7 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-
-/**
- *
- * @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 {number} ref_x
- * @param {number} ref_y
- * @param {number} ref_z
- * @return {number}
- */
-export function ray3_distance_to_point(
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    ref_x, ref_y, ref_z
-) {
-    // find the closest point
-    const sp0_x = ref_x - origin_x;
-    const sp0_y = ref_y - origin_y;
-    const sp0_z = ref_z - origin_z;
-
-    //
-    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
-    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
-
-    return d3 / d2;
-}
+import { ray3_compute_point_projection_t } from "./ray3_compute_point_projection_t.js";
+
+/**
+ * @deprecated Renamed to {@link ray3_compute_point_projection_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const ray3_distance_to_point = ray3_compute_point_projection_t;

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.d.ts

@@ -1,10 +1,7 @@
 /**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
- * @param {number} output_offset
- * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
- * @param {number} input_offset
- * @param {number} distance
+ * @deprecated Renamed to {@link ray3_shift_origin_along_direction_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function ray3_shift_origin_along_direction(output: number[] | ArrayLike<number> | Float32Array, output_offset: number, input: number[] | ArrayLike<number> | Float32Array, input_offset: number, distance: number): void;
+export const ray3_shift_origin_along_direction: typeof ray3_shift_origin_along_direction_array;
+import { ray3_shift_origin_along_direction_array } from "./ray3_shift_origin_along_direction_array.js";
 //# sourceMappingURL=ray3_shift_origin_along_direction.d.ts.map

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray3_shift_origin_along_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_shift_origin_along_direction.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,0DANW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,YACN,MAAM,QAyBhB"}
+{"version":3,"file":"ray3_shift_origin_along_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_shift_origin_along_direction.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,+FAAyF;wDANjC,8CAA8C"}

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction.js

@@ -1,35 +1,7 @@
-import { v3_array_displace_in_direction } from "../../vec3/v3_array_displace_in_direction.js";
-
-/**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
- * @param {number} output_offset
- * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
- * @param {number} input_offset
- * @param {number} distance
- */
-export function ray3_shift_origin_along_direction(
-    output, output_offset,
-    input, input_offset,
-    distance
-) {
-    const origin_x = input[input_offset + 0];
-    const origin_y = input[input_offset + 1];
-    const origin_z = input[input_offset + 2];
-
-    const direction_x = input[input_offset + 3];
-    const direction_y = input[input_offset + 4];
-    const direction_z = input[input_offset + 5];
-
-    v3_array_displace_in_direction(
-        output, 0,
-        origin_x, origin_y, origin_z,
-        direction_x, direction_y, direction_z,
-        distance
-    );
-
-    output[output_offset + 3] = direction_x;
-    output[output_offset + 4] = direction_y;
-    output[output_offset + 5] = direction_z;
-}
-
+import { ray3_shift_origin_along_direction_array } from "./ray3_shift_origin_along_direction_array.js";
+
+/**
+ * @deprecated Renamed to {@link ray3_shift_origin_along_direction_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const ray3_shift_origin_along_direction = ray3_shift_origin_along_direction_array;

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction_array.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} input_offset
+ * @param {number} distance
+ */
+export function ray3_shift_origin_along_direction_array(output: number[] | ArrayLike<number> | Float32Array, output_offset: number, input: number[] | ArrayLike<number> | Float32Array, input_offset: number, distance: number): void;
+//# sourceMappingURL=ray3_shift_origin_along_direction_array.d.ts.map

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray3_shift_origin_along_direction_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_shift_origin_along_direction_array.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,gEANW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,YACN,MAAM,QAyBhB"}

package/src/core/geom/3d/ray/ray3_shift_origin_along_direction_array.js

@@ -0,0 +1,35 @@
+import { v3_displace_in_direction_to_array } from "../../vec3/v3_displace_in_direction_to_array.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} input_offset
+ * @param {number} distance
+ */
+export function ray3_shift_origin_along_direction_array(
+    output, output_offset,
+    input, input_offset,
+    distance
+) {
+    const origin_x = input[input_offset + 0];
+    const origin_y = input[input_offset + 1];
+    const origin_z = input[input_offset + 2];
+
+    const direction_x = input[input_offset + 3];
+    const direction_y = input[input_offset + 4];
+    const direction_z = input[input_offset + 5];
+
+    v3_displace_in_direction_to_array(
+        output, output_offset,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        distance
+    );
+
+    output[output_offset + 3] = direction_x;
+    output[output_offset + 4] = direction_y;
+    output[output_offset + 5] = direction_z;
+}
+

package/src/core/geom/3d/shape/AbstractShape3D.d.ts

@@ -59,6 +59,19 @@ export class AbstractShape3D {
      * @returns {void}
      */
     support(result: number[] | Float32Array | Float64Array, result_offset: number, direction_x: number, direction_y: number, direction_z: number): void;
+    /**
+     * Ray ↔ shape intersection in the shape's LOCAL frame (the shape sits at the origin in its canonical
+     * pose). On a hit, writes the surface point and unit surface normal into `hit` as
+     * `[px, py, pz, nx, ny, nz]` and returns true; on a miss returns false and leaves `hit` untouched.
+     *
+     * PRECONDITION: the ray direction is unit length, so the hit distance `t` is a true distance and can
+     * be recovered by the caller as `(hitPoint − origin)·direction`.
+     *
+     * @param {Float32Array|number[]} hit destination, [px, py, pz, nx, ny, nz]
+     * @param {Ray3} ray local-frame ray (origin in [0..2], unit direction in [3..5], tMax in [6])
+     * @returns {boolean}
+     */
+    raycast(hit: Float32Array | number[], ray: Ray3): boolean;
     /**
      * @template {AbstractShape3D} T
      * @param {T} other

package/src/core/geom/3d/shape/AbstractShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AAAA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,6CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC"}
+{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AAAA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC"}

package/src/core/geom/3d/shape/AbstractShape3D.js

@@ -86,6 +86,22 @@ export class AbstractShape3D {
         throw new Error("Not Implemented");
     }
 
+    /**
+     * Ray ↔ shape intersection in the shape's LOCAL frame (the shape sits at the origin in its canonical
+     * pose). On a hit, writes the surface point and unit surface normal into `hit` as
+     * `[px, py, pz, nx, ny, nz]` and returns true; on a miss returns false and leaves `hit` untouched.
+     *
+     * PRECONDITION: the ray direction is unit length, so the hit distance `t` is a true distance and can
+     * be recovered by the caller as `(hitPoint − origin)·direction`.
+     *
+     * @param {Float32Array|number[]} hit destination, [px, py, pz, nx, ny, nz]
+     * @param {Ray3} ray local-frame ray (origin in [0..2], unit direction in [3..5], tMax in [6])
+     * @returns {boolean}
+     */
+    raycast(hit, ray) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      * @template {AbstractShape3D} T
      * @param {T} other

package/src/core/geom/3d/shape/BoxShape3D.d.ts

@@ -38,6 +38,7 @@ export class BoxShape3D extends AbstractShape3D {
     compute_bounding_box(result: any): void;
     nearest_point_on_surface(result: any, reference: any): void;
     support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    raycast(hit: any, ray: any): boolean;
     signed_distance_gradient_at_point(result: any, point: any): number;
     signed_distance_at_point(point: any): number;
     contains_point(point: any): boolean;

package/src/core/geom/3d/shape/BoxShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;GAYG;AACH;IAYI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA/BG;;;;OAIG;IACH,uBAFU,OAAO,CAE6B;IAsClD,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,mEAEC;IAED,6CAaC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCA3I+B,sBAAsB;oBATlC,kBAAkB"}
+{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH;IAYI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA/BG;;;;OAIG;IACH,uBAFU,OAAO,CAE6B;IAsClD,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,qCAaC;IAED,mEAEC;IAED,6CAaC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCA1J+B,sBAAsB;oBAVlC,kBAAkB"}

package/src/core/geom/3d/shape/BoxShape3D.js

@@ -4,9 +4,10 @@ import { max3 } from "../../../math/max3.js";
 import { min2 } from "../../../math/min2.js";
 import { sign_not_zero } from "../../../math/sign_not_zero.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { randomPointInBox } from "../../random/randomPointInBox.js";
+import { random_point_in_box } from "../../random/random_point_in_box.js";
 import { v3_length } from "../../vec3/v3_length.js";
-import { aabb3_nearest_point_on_surface } from "../aabb/aabb3_nearest_point_on_surface.js";
+import { aabb3_closest_point_on_surface } from "../aabb/aabb3_closest_point_on_surface.js";
+import { box3_raycast } from "../box/box3_raycast.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
@@ -78,7 +79,7 @@ export class BoxShape3D extends AbstractShape3D {
 
     nearest_point_on_surface(result, reference) {
         const h = this.half_extents;
-        aabb3_nearest_point_on_surface(
+        aabb3_closest_point_on_surface(
             result,
             -h.x, -h.y, -h.z,
              h.x,  h.y,  h.z,
@@ -93,6 +94,21 @@ export class BoxShape3D extends AbstractShape3D {
         result[result_offset + 2] = sign_not_zero(direction_z) * h.z;
     }
 
+    raycast(hit, ray) {
+        const h = this.half_extents;
+        const t = box3_raycast(hit, 3, ray[0], ray[1], ray[2], ray[3], ray[4], ray[5], ray[6], h.x, h.y, h.z);
+
+        if (t === Infinity) {
+            return false;
+        }
+
+        hit[0] = ray[0] + ray[3] * t;
+        hit[1] = ray[1] + ray[4] * t;
+        hit[2] = ray[2] + ray[5] * t;
+
+        return true;
+    }
+
     signed_distance_gradient_at_point(result, point) {
         return compute_signed_distance_gradient_by_sampling(result, this, point);
     }
@@ -123,9 +139,9 @@ export class BoxShape3D extends AbstractShape3D {
     }
 
     sample_random_point_in_volume(result, result_offset, random) {
-        randomPointInBox(random, result, result_offset);
+        random_point_in_box(random, result, result_offset);
         const h = this.half_extents;
-        // randomPointInBox samples a unit cube — rescale to our half-extents.
+        // random_point_in_box samples a unit cube — rescale to our half-extents.
         result[result_offset]     *= h.x * 2;
         result[result_offset + 1] *= h.y * 2;
         result[result_offset + 2] *= h.z * 2;

package/src/core/geom/3d/shape/CapsuleShape3D.d.ts

@@ -21,6 +21,7 @@ export class CapsuleShape3D extends AbstractShape3D {
      */
     height: number;
     compute_bounding_box(result: any): void;
+    raycast(hit: any, ray: any): boolean;
     signed_distance_at_point(point: any): number;
     signed_distance_gradient_at_point(result: any, point: any): number;
     contains_point(point: any): boolean;

package/src/core/geom/3d/shape/CapsuleShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CapsuleShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CapsuleShape3D.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH;IAiBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,cAAc,CAa1B;IA7BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAqCnB,wCAUC;IAED,6CAaC;IAED,mEAEC;IAED,oCAcC;IAED,4DA+BC;IAED,qGAUC;IAED,kFA+BC;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAMnB;IAUL;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEwB;CAZxC;gCA1M+B,sBAAsB"}
+{"version":3,"file":"CapsuleShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CapsuleShape3D.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH;IAiBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,cAAc,CAa1B;IA7BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAqCnB,wCAUC;IAED,qCAgBC;IAED,6CAaC;IAED,mEAEC;IAED,oCAcC;IAED,4DA+BC;IAED,qGAUC;IAED,kFA+BC;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAMnB;IAUL;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEwB;CAZxC;gCA5N+B,sBAAsB"}

package/src/core/geom/3d/shape/CapsuleShape3D.js

@@ -2,9 +2,10 @@ import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { sign_not_zero } from "../../../math/sign_not_zero.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { randomPointInCircle } from "../../random/randomPointInCircle.js";
-import { randomPointInSphere } from "../../random/randomPointInSphere.js";
+import { random_point_in_circle } from "../../random/random_point_in_circle.js";
+import { random_point_in_sphere } from "../../random/random_point_in_sphere.js";
 import { v3_length } from "../../vec3/v3_length.js";
+import { capsule_raycast } from "../capsule/capsule_raycast.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
@@ -78,6 +79,24 @@ export class CapsuleShape3D extends AbstractShape3D {
         result[5] = r;
     }
 
+    raycast(hit, ray) {
+        const t = capsule_raycast(
+            hit, 3,
+            ray[0], ray[1], ray[2], ray[3], ray[4], ray[5], ray[6],
+            this.radius, this.height * 0.5
+        );
+
+        if (t === Infinity) {
+            return false;
+        }
+
+        hit[0] = ray[0] + ray[3] * t;
+        hit[1] = ray[1] + ray[4] * t;
+        hit[2] = ray[2] + ray[5] * t;
+
+        return true;
+    }
+
     signed_distance_at_point(point) {
         const px = point[0];
         const py = point[1];
@@ -170,7 +189,7 @@ export class CapsuleShape3D extends AbstractShape3D {
 
         if (pick < cylinder_volume) {
             // sample inside the cylindrical core
-            randomPointInCircle(random, scratch_v3, 0);
+            random_point_in_circle(random, scratch_v3, 0);
 
             const y = (random() - 0.5) * h;
 
@@ -179,7 +198,7 @@ export class CapsuleShape3D extends AbstractShape3D {
             result[result_offset + 2] = scratch_v3[1] * r;
         } else {
             // sample inside a hemispherical cap
-            randomPointInSphere(random, scratch_v3, 0);
+            random_point_in_sphere(random, scratch_v3, 0);
 
             const sy = scratch_v3[1];
 

package/src/core/geom/3d/shape/ConvexHullShape3D.js

@@ -1,5 +1,5 @@
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { computeTriangleClosestPointToPointBarycentric } from "../triangle/computeTriangleClosestPointToPointBarycentric.js";
+import { tri3_closest_point_barycentric } from "../triangle/tri3_closest_point_barycentric.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
@@ -221,7 +221,7 @@ export class ConvexHullShape3D extends AbstractShape3D {
             const ax = v[ia], ay = v[ia + 1], az = v[ia + 2];
             const bx = v[ib], by = v[ib + 1], bz = v[ib + 2];
             const cx = v[ic], cy = v[ic + 1], cz = v[ic + 2];
-            computeTriangleClosestPointToPointBarycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
+            tri3_closest_point_barycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
             const u = baryc[0], w = baryc[1], t = 1 - u - w;
             const qx = u * ax + w * bx + t * cx;
             const qy = u * ay + w * by + t * cy;
@@ -252,7 +252,7 @@ export class ConvexHullShape3D extends AbstractShape3D {
             const ax = v[ia], ay = v[ia + 1], az = v[ia + 2];
             const bx = v[ib], by = v[ib + 1], bz = v[ib + 2];
             const cx = v[ic], cy = v[ic + 1], cz = v[ic + 2];
-            computeTriangleClosestPointToPointBarycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
+            tri3_closest_point_barycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
             const u = baryc[0], w = baryc[1], t = 1 - u - w;
             const qx = u * ax + w * bx + t * cx;
             const qy = u * ay + w * by + t * cy;

package/src/core/geom/3d/shape/CylinderShape3D.js

@@ -2,7 +2,7 @@ import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { sign_not_zero } from "../../../math/sign_not_zero.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { randomPointInCircle } from "../../random/randomPointInCircle.js";
+import { random_point_in_circle } from "../../random/random_point_in_circle.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
@@ -187,7 +187,7 @@ export class CylinderShape3D extends AbstractShape3D {
 
     sample_random_point_in_volume(result, result_offset, random) {
         // Uniform in the disk (sqrt-weighted radius) × uniform in y.
-        randomPointInCircle(random, scratch_v3, 0);
+        random_point_in_circle(random, scratch_v3, 0);
 
         result[result_offset] = scratch_v3[0] * this.radius;
         result[result_offset + 1] = (random() - 0.5) * this.height;

package/src/core/geom/3d/shape/MeshShape3D.d.ts

@@ -100,12 +100,47 @@ export class MeshShape3D extends AbstractShape3D {
      * @type {number}
      */
     private __surface_area;
+    /**
+     * Lazily-built surface-triangle BVH for {@link raycast} (distinct from {@link tet_bvh}, which
+     * keys the interior tets). Built on the first ray query from `positions` / `indices`; null until
+     * then. Mutating the surface invalidates it (set back to null to rebuild).
+     * @private
+     * @type {BVH|null}
+     */
+    private __raycast_blas;
     compute_bounding_box(result: any): void;
     /**
-     * Refresh the cached bounding box, volume, and surface area from the
-     * current `positions` / `indices` / `tet_mesh`. Called by
-     * {@link shape_mesh_from_geometry} at construction; call again after
-     * mutating the underlying data.
+     * Nearest surface hit of `ray` (local frame) within `ray[6]` (tMax), writing
+     * `[px,py,pz, nx,ny,nz]` into `hit`. Two intentional divergences from the
+     * analytic sphere/box/capsule shapes, both stemming from a triangle mesh
+     * having no guaranteed winding and no closed form:
+     *
+     *  - NORMAL: the face normal is flipped to face the incoming ray, so an
+     *    EXTERNAL hit yields the outward surface normal regardless of winding.
+     *    For a ray originating INSIDE a closed mesh the reported normal therefore
+     *    points back toward the ray (i.e. inward), where the analytic shapes
+     *    would report the true outward normal of the exit surface.
+     *  - tMax BOUNDARY: exclusive — a hit at exactly t == tMax is reported as a
+     *    miss (the underlying nearest-triangle query seeds best_t = tMax and only
+     *    accepts strictly nearer hits), whereas the analytic shapes are inclusive
+     *    at tMax. A single-ULP grazing edge; left as-is rather than altering the
+     *    shared `ebvh_geometry_query_nearest_triangle_ray` used across physics.
+     *
+     * Builds an internal BVH over the triangles on first use (lazy), cached on the
+     * shape; {@link recompute_cached} invalidates it after surface mutation.
+     *
+     * @param {Float32Array} hit out: [px,py,pz, nx,ny,nz]
+     * @param {Ray3} ray local-frame ray (unit direction; ray[6] = tMax)
+     * @returns {boolean} whether anything was hit
+     */
+    raycast(hit: Float32Array, ray: Ray3): boolean;
+    /**
+     * Refresh the cached bounding box, volume, surface area, and the lazy
+     * raycast BLAS from the current `positions` / `indices` / `tet_mesh`.
+     * Called by {@link shape_mesh_from_geometry} at construction; call again
+     * after mutating the underlying data so every cached derivative — the
+     * raycast acceleration structure included — is rebuilt against the new
+     * surface rather than silently serving stale results.
      */
     recompute_cached(): void;
     /**

package/src/core/geom/3d/shape/MeshShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAW3B,wCAIC;IAED;;;;;OAKG;IACH,yBAmDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAyCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAxe+B,sBAAsB;gCADtB,kCAAkC;oBAJ9C,2BAA2B"}
+{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAEvB;;;;;;OAMG;IACH,uBAA0B;IAW9B,wCAIC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAJW,YAAY,cAEV,OAAO,CA+DnB;IAED;;;;;;;OAOG;IACH,yBAyDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAyCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAnlB+B,sBAAsB;gCADtB,kCAAkC;oBAN9C,2BAA2B"}