@woosh/meep-engine 2.138.17 → 2.138.19

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

@@ -1,65 +1,57 @@
-import { clamp } from "../../../math/clamp.js";
-import { min2 } from "../../../math/min2.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
- */
-export function aabb3_nearest_point_on_surface(result, x0, y0, z0, x1, y1, z1, r_x, r_y, r_z) {
-    const ar_x0 = Math.abs(r_x - x0);
-    const ar_x1 = Math.abs(r_x - x1);
-    const ar_x_min = min2(ar_x0, ar_x1);
-
-    const ar_y0 = Math.abs(r_y - y0);
-    const ar_y1 = Math.abs(r_y - y1);
-    const ar_y_min = min2(ar_y0, ar_y1);
-
-    const ar_z0 = Math.abs(r_z - z0);
-    const ar_z1 = Math.abs(r_z - z1);
-    const ar_z_min = min2(ar_z0, ar_z1);
-
-    // figure out closest face to the reference point
-    if (ar_x_min > ar_y_min && ar_x_min > ar_z_min) {
-        // X is smallest, project onto X axis
-        if (ar_x0 <= ar_x1) {
-            result[0] = x0;
-        } else {
-            result[0] = x1;
-        }
-
-        result[1] = clamp(r_y, y0, y1);
-        result[2] = clamp(r_z, z0, z1);
-    } else if (ar_y_min > ar_x_min && ar_y_min > ar_z_min) {
-        // Y is smallest, project onto X axis
-        if (ar_y0 <= ar_y1) {
-            result[1] = y0;
-        } else {
-            result[1] = y1;
-        }
-
-        result[0] = clamp(r_x, x0, x1);
-        result[2] = clamp(r_z, z0, z1);
-    } else {
-        // project onto Z axis
-
-        if (ar_z0 <= ar_z1) {
-            result[2] = z0;
-        } else {
-            result[2] = z1;
-        }
-
-        result[0] = clamp(r_x, x0, x1);
-        result[1] = clamp(r_y, y0, y1);
-    }
-}
+import { clamp } from "../../../math/clamp.js";
+import { min2 } from "../../../math/min2.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
+ */
+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;
+    }
+}

package/src/core/geom/3d/octahedra/octahedral_uv_wrap.d.ts

@@ -24,7 +24,7 @@
  * @param {number} in_offset - Index to start reading from
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export function octahedral_uv_wrap(out_uv: number[], out_offset: number, in_uv: number[], in_offset: number): void;
 //# sourceMappingURL=octahedral_uv_wrap.d.ts.map

package/src/core/geom/3d/octahedra/octahedral_uv_wrap.js

@@ -31,7 +31,7 @@ function reduce_even_wrap(x) {
  * @param {number} in_offset - Index to start reading from
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export function octahedral_uv_wrap(
     out_uv, out_offset,

package/src/core/geom/3d/quaternion/quat_decode_from_uint32.d.ts

@@ -2,7 +2,7 @@
  * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  *
  * @param {number[]} output
  * @param {number} output_offset

package/src/core/geom/3d/quaternion/quat_decode_from_uint32.js

@@ -4,7 +4,7 @@ const K = Math.SQRT1_2 / 511;
  * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  *
  * @param {number[]} output
  * @param {number} output_offset

package/src/core/geom/3d/quaternion/quat_encode_to_uint32.d.ts

@@ -2,7 +2,7 @@
  * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  *
  * @param {number} x
  * @param {number} y

package/src/core/geom/3d/quaternion/quat_encode_to_uint32.js

@@ -5,7 +5,7 @@ import { v4_length } from "../../vec4/v4_length.js";
  * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  *
  * @param {number} x
  * @param {number} y

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

@@ -1,3 +1,74 @@
-export class AbstractShape3D {
-
-}
+export class AbstractShape3D {
+    /**
+     * Signed distance to boundary of the shape from the given point
+     * @param {number[]} point
+     * @returns {number}
+     */
+    signed_distance_at_point(point: number[]): number;
+    /**
+     * Samples both distances as well as the gradient
+     * @param {number[]} result resulting gradient is written here
+     * @param {number[]} point sampling point
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result: number[], point: number[]): number;
+    /**
+     *
+     * @param {number[]} result where the resulting point is stored
+     * @param {number[]} reference reference point from which to go
+     * @returns {void}
+     */
+    nearest_point_on_surface(result: number[], reference: number[]): void;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {function} random
+     * @returns {void}
+     */
+    sample_random_point_in_volume(result: number[], result_offset: number, random: Function): void;
+    /**
+     * Whether or not given point is inside the shape
+     * @param {number[]} point
+     * @returns {boolean}
+     */
+    contains_point(point: number[]): boolean;
+    /**
+     * Total volume of the shape
+     * @returns {number}
+     */
+    get volume(): number;
+    /**
+     * @returns {number}
+     */
+    get surface_area(): number;
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} result format: x0,y0,z0,x1,y1,z1
+     * @returns {void}
+     */
+    compute_bounding_box(result: number[] | ArrayLike<number> | Float32Array | Float64Array): void;
+    /**
+     * Support function, given a direction vector, return point on the shape that's furthest in that direction
+     * Assumes direction is a unit vector
+     * @param {number[]|Float32Array} result
+     * @param {number} result_offset
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @returns {void}
+     */
+    support(result: number[] | Float32Array, result_offset: number, direction_x: number, direction_y: number, direction_z: number): void;
+    /**
+     * @template {AbstractShape3D} T
+     * @param {T} other
+     * @returns {boolean}
+     */
+    equals<T extends AbstractShape3D>(other: T): boolean;
+    /**
+     *
+     * @returns {number}
+     */
+    hash(): number;
+}
+//# sourceMappingURL=AbstractShape3D.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * A capsule aligned with the Y axis. Composed of a cylindrical section of
+ * length {@link height} and two hemispherical caps of radius {@link radius}.
+ * Total extent along Y is `height + 2 * radius`.
+ */
+export class CapsuleShape3D extends AbstractShape3D {
+    /**
+     * @param {number} radius
+     * @param {number} height
+     * @returns {CapsuleShape3D}
+     */
+    static from(radius: number, height: number): CapsuleShape3D;
+    /**
+     * Radius of the hemispherical caps and the cylindrical section
+     * @type {number}
+     */
+    radius: number;
+    /**
+     * Length of the cylindrical (straight) section, NOT including the hemispheres
+     * @type {number}
+     */
+    height: number;
+    compute_bounding_box(result: any): void;
+    signed_distance_at_point(point: any): number;
+    signed_distance_gradient_at_point(result: any, point: any): number;
+    contains_point(point: any): boolean;
+    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;
+    sample_random_point_in_volume(result: any, result_offset: any, random: any): void;
+    /**
+     * @param {CapsuleShape3D} other
+     * @returns {boolean}
+     */
+    equals(other: CapsuleShape3D): boolean;
+}
+import { AbstractShape3D } from "./AbstractShape3D.js";
+//# sourceMappingURL=CapsuleShape3D.d.ts.map

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

@@ -0,0 +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;CAQJ;gCA1M+B,sBAAsB"}

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

@@ -0,0 +1,210 @@
+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 { v3_length } from "../../vec3/v3_length.js";
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+
+const scratch_v3 = [0, 0, 0];
+
+/**
+ * A capsule aligned with the Y axis. Composed of a cylindrical section of
+ * length {@link height} and two hemispherical caps of radius {@link radius}.
+ * Total extent along Y is `height + 2 * radius`.
+ */
+export class CapsuleShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         * Radius of the hemispherical caps and the cylindrical section
+         * @type {number}
+         */
+        this.radius = 0.5;
+
+        /**
+         * Length of the cylindrical (straight) section, NOT including the hemispheres
+         * @type {number}
+         */
+        this.height = 1;
+    }
+
+    /**
+     * @param {number} radius
+     * @param {number} height
+     * @returns {CapsuleShape3D}
+     */
+    static from(radius, height) {
+        assert.isNumber(radius, 'radius');
+        assert.isNumber(height, 'height');
+        assert.greaterThanOrEqual(radius, 0, 'radius');
+        assert.greaterThanOrEqual(height, 0, 'height');
+
+        const r = new CapsuleShape3D();
+        r.radius = radius;
+        r.height = height;
+
+        return r;
+    }
+
+    get volume() {
+        const r = this.radius;
+        const h = this.height;
+
+        // cylindrical core + full sphere (two hemispheres)
+        return Math.PI * r * r * h + (4 / 3) * Math.PI * r * r * r;
+    }
+
+    get surface_area() {
+        const r = this.radius;
+        const h = this.height;
+
+        // side of the cylinder + full sphere surface (two hemispheres)
+        return 2 * Math.PI * r * h + 4 * Math.PI * r * r;
+    }
+
+    compute_bounding_box(result) {
+        const r = this.radius;
+        const half_h = this.height / 2;
+
+        result[0] = -r;
+        result[1] = -half_h - r;
+        result[2] = -r;
+        result[3] = r;
+        result[4] = half_h + r;
+        result[5] = r;
+    }
+
+    signed_distance_at_point(point) {
+        const px = point[0];
+        const py = point[1];
+        const pz = point[2];
+
+        const half_h = this.height / 2;
+
+        // collapse Y onto the central segment
+        const y_seg = clamp(py, -half_h, half_h);
+
+        const dy = py - y_seg;
+
+        return v3_length(px, dy, pz) - this.radius;
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
+    }
+
+    contains_point(point) {
+        const px = point[0];
+        const py = point[1];
+        const pz = point[2];
+
+        const half_h = this.height / 2;
+
+        const y_seg = clamp(py, -half_h, half_h);
+
+        const dy = py - y_seg;
+
+        const r = this.radius;
+
+        return px * px + dy * dy + pz * pz < r * r;
+    }
+
+    nearest_point_on_surface(result, reference) {
+        const rx = reference[0];
+        const ry = reference[1];
+        const rz = reference[2];
+
+        const half_h = this.height / 2;
+
+        // closest point on the central segment
+        const y_seg = clamp(ry, -half_h, half_h);
+
+        const dx = rx;
+        const dy = ry - y_seg;
+        const dz = rz;
+
+        const dist = v3_length(dx, dy, dz);
+
+        const r = this.radius;
+
+        if (dist === 0) {
+            // reference is on the central axis, pick an arbitrary surface direction (+X)
+            result[0] = r;
+            result[1] = y_seg;
+            result[2] = 0;
+            return;
+        }
+
+        const scale = r / dist;
+
+        result[0] = dx * scale;
+        result[1] = y_seg + dy * scale;
+        result[2] = dz * scale;
+    }
+
+    support(result, result_offset, direction_x, direction_y, direction_z) {
+        const half_h = this.height / 2;
+        const r = this.radius;
+
+        // pick the hemisphere whose center is along +direction.y
+        const cap_y = sign_not_zero(direction_y) * half_h;
+
+        result[result_offset] = direction_x * r;
+        result[result_offset + 1] = cap_y + direction_y * r;
+        result[result_offset + 2] = direction_z * r;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        const r = this.radius;
+        const h = this.height;
+
+        const cylinder_volume = Math.PI * r * r * h;
+        const sphere_volume = (4 / 3) * Math.PI * r * r * r;
+        const total_volume = cylinder_volume + sphere_volume;
+
+        const pick = random() * total_volume;
+
+        if (pick < cylinder_volume) {
+            // sample inside the cylindrical core
+            randomPointInCircle(random, scratch_v3, 0);
+
+            const y = (random() - 0.5) * h;
+
+            result[result_offset] = scratch_v3[0] * r;
+            result[result_offset + 1] = y;
+            result[result_offset + 2] = scratch_v3[1] * r;
+        } else {
+            // sample inside a hemispherical cap
+            randomPointInSphere(random, scratch_v3, 0);
+
+            const sy = scratch_v3[1];
+
+            const cap_offset = sign_not_zero(sy) * (h / 2);
+
+            result[result_offset] = scratch_v3[0] * r;
+            result[result_offset + 1] = sy * r + cap_offset;
+            result[result_offset + 2] = scratch_v3[2] * r;
+        }
+    }
+
+    /**
+     * @param {CapsuleShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other)
+            && this.radius === other.radius
+            && this.height === other.height;
+    }
+
+    hash() {
+        const a = computeHashFloat(this.radius);
+        const b = computeHashFloat(this.height);
+
+        return ((a << 5) - a + b) | 0;
+    }
+}

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

@@ -3,6 +3,11 @@
  */
 export class PointShape3D extends AbstractShape3D {
     static INSTANCE: PointShape3D;
+    compute_bounding_box(result: any): void;
+    signed_distance_at_point(point: any): number;
+    contains_point(point: any): boolean;
+    nearest_point_on_surface(result: any, reference: any): void;
+    sample_random_point_in_volume(result: any, result_offset: any, random: any): void;
     support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
 }
 import { AbstractShape3D } from "./AbstractShape3D.js";

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

@@ -1 +1 @@
-{"version":3,"file":"PointShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PointShape3D.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAOI,8BAAqC;IANrC,qGAIC;CAGJ;gCAb+B,sBAAsB"}
+{"version":3,"file":"PointShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PointShape3D.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IA4CI,8BAAqC;IAnCrC,wCAOC;IAED,6CAEC;IAED,oCAEC;IAED,4DAIC;IAED,kFAIC;IAED,qGAIC;CAGJ;gCAlD+B,sBAAsB"}

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

@@ -1,14 +1,52 @@
-import { AbstractShape3D } from "./AbstractShape3D.js";
-
-/**
- * Describes a point, shape that encloses no space
- */
-export class PointShape3D extends AbstractShape3D {
-    support(result, result_offset, direction_x, direction_y, direction_z) {
-        result[result_offset] = 0;
-        result[result_offset + 1] = 0;
-        result[result_offset + 2] = 0;
-    }
-
-    static INSTANCE = new PointShape3D();
-}
+import { v3_length } from "../../vec3/v3_length.js";
+import { AbstractShape3D } from "./AbstractShape3D.js";
+
+/**
+ * Describes a point, shape that encloses no space
+ */
+export class PointShape3D extends AbstractShape3D {
+    get volume() {
+        return 0;
+    }
+
+    get surface_area() {
+        return 0;
+    }
+
+    compute_bounding_box(result) {
+        result[0] = 0;
+        result[1] = 0;
+        result[2] = 0;
+        result[3] = 0;
+        result[4] = 0;
+        result[5] = 0;
+    }
+
+    signed_distance_at_point(point) {
+        return v3_length(point[0], point[1], point[2]);
+    }
+
+    contains_point(point) {
+        return false;
+    }
+
+    nearest_point_on_surface(result, reference) {
+        result[0] = 0;
+        result[1] = 0;
+        result[2] = 0;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+        result[result_offset + 2] = 0;
+    }
+
+    support(result, result_offset, direction_x, direction_y, direction_z) {
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+        result[result_offset + 2] = 0;
+    }
+
+    static INSTANCE = new PointShape3D();
+}