@woosh/meep-engine 2.153.0 → 2.155.0

package/src/engine/physics/events/ContactEventBuffer.js

@@ -1,83 +1,84 @@
-/**
- * Event kinds emitted by the manifold diff pass.
- * @readonly
- * @enum {number}
- */
-export const ContactEventKind = {
-    Begin: 0,
-    Stay: 1,
-    End: 2,
-};
-
-const DEFAULT_INITIAL_CAPACITY = 32;
-
-/**
- * Per-event stride in the Uint32 backing array:
- *   0 : kind (ContactEventKind)
- *   1 : entityA
- *   2 : entityB
- *   3 : slot
- * @type {number}
- */
-const EVENT_STRIDE = 4;
-
-/**
- * Append-only buffer of contact events produced during one fixedUpdate, ready
- * to be dispatched (and then cleared) at end-of-step.
- *
- * Storage is flat Uint32Array — keeping the metadata side allocation-free; the
- * actual contact payload (normal, depth, world point) is read on demand from
- * the {@link ManifoldStore} by the dispatch code.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ContactEventBuffer {
-    /**
-     * @param {number} [initial_capacity] events
-     */
-    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
-        this.__capacity = Math.max(1, initial_capacity);
-        this.__count = 0;
-        // Int32 so entity ids may legitimately store -1 (stale body after free).
-        this.__data = new Int32Array(this.__capacity * EVENT_STRIDE);
-    }
-
-    /**
-     * @returns {number}
-     */
-    get count() {
-        return this.__count;
-    }
-
-    clear() {
-        this.__count = 0;
-    }
-
-    /**
-     * @param {ContactEventKind|number} kind
-     * @param {number} entityA
-     * @param {number} entityB
-     * @param {number} slot manifold slot id
-     */
-    push(kind, entityA, entityB, slot) {
-        if (this.__count === this.__capacity) {
-            const new_cap = this.__capacity << 1;
-            const next = new Int32Array(new_cap * EVENT_STRIDE);
-            next.set(this.__data);
-            this.__data = next;
-            this.__capacity = new_cap;
-        }
-        const off = this.__count * EVENT_STRIDE;
-        this.__data[off] = kind;
-        this.__data[off + 1] = entityA;
-        this.__data[off + 2] = entityB;
-        this.__data[off + 3] = slot;
-        this.__count++;
-    }
-
-    kind_at(i) { return this.__data[i * EVENT_STRIDE]; }
-    entityA_at(i) { return this.__data[i * EVENT_STRIDE + 1]; }
-    entityB_at(i) { return this.__data[i * EVENT_STRIDE + 2]; }
-    slot_at(i) { return this.__data[i * EVENT_STRIDE + 3]; }
-}
+/**
+ * Event kinds emitted by the manifold diff pass.
+ * @readonly
+ * @enum {number}
+ */
+export const ContactEventKind = {
+    Begin: 0,
+    Stay: 1,
+    End: 2,
+};
+
+const DEFAULT_INITIAL_CAPACITY = 32;
+
+/**
+ * Per-event stride in the Int32 backing array:
+ *   0 : kind (ContactEventKind)
+ *   1 : entityA
+ *   2 : entityB
+ *   3 : slot
+ * @type {number}
+ */
+const EVENT_STRIDE = 4;
+
+/**
+ * Append-only buffer of contact events produced during one fixedUpdate, ready
+ * to be dispatched (and then cleared) at end-of-step.
+ *
+ * Storage is flat Int32Array (signed: entity ids may legitimately be -1 for a
+ * stale body after free) — keeping the metadata side allocation-free; the
+ * actual contact payload (normal, depth, world point) is read on demand from
+ * the {@link ManifoldStore} by the dispatch code.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ContactEventBuffer {
+    /**
+     * @param {number} [initial_capacity] events
+     */
+    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
+        this.__capacity = Math.max(1, initial_capacity);
+        this.__count = 0;
+        // Int32 so entity ids may legitimately store -1 (stale body after free).
+        this.__data = new Int32Array(this.__capacity * EVENT_STRIDE);
+    }
+
+    /**
+     * @returns {number}
+     */
+    get count() {
+        return this.__count;
+    }
+
+    clear() {
+        this.__count = 0;
+    }
+
+    /**
+     * @param {ContactEventKind|number} kind
+     * @param {number} entityA
+     * @param {number} entityB
+     * @param {number} slot manifold slot id
+     */
+    push(kind, entityA, entityB, slot) {
+        if (this.__count === this.__capacity) {
+            const new_cap = this.__capacity << 1;
+            const next = new Int32Array(new_cap * EVENT_STRIDE);
+            next.set(this.__data);
+            this.__data = next;
+            this.__capacity = new_cap;
+        }
+        const off = this.__count * EVENT_STRIDE;
+        this.__data[off] = kind;
+        this.__data[off + 1] = entityA;
+        this.__data[off + 2] = entityB;
+        this.__data[off + 3] = slot;
+        this.__count++;
+    }
+
+    kind_at(i) { return this.__data[i * EVENT_STRIDE]; }
+    entityA_at(i) { return this.__data[i * EVENT_STRIDE + 1]; }
+    entityB_at(i) { return this.__data[i * EVENT_STRIDE + 2]; }
+    slot_at(i) { return this.__data[i * EVENT_STRIDE + 3]; }
+}

package/src/engine/physics/gjk/gjk.d.ts

@@ -13,30 +13,4 @@
  * @returns {boolean} true if the shapes intersect
  */
 export function gjk(simplex: number[] | Float64Array, shape_a: AbstractShape3D, shape_b: AbstractShape3D): boolean;
-/**
- * Separating-axis-cached variant of {@link gjk}. The 3 floats at
- * `axis_buffer[axis_offset..+2]` are used as the initial search
- * direction (seed) AND are overwritten with the final search direction
- * on exit. The narrowphase keeps a per-manifold-slot cache of these
- * three floats so quiescent contacts converge in 1–2 iterations next
- * frame instead of ~6–10 from a cold `(1, 0, 0)` start (Bullet's
- * `m_cachedSeparatingAxis` and Jolt's `ioV` use the same pattern).
- *
- * The same primitive doubles as a separating-axis cache for the
- * "no-overlap" path: when GJK returns false, the final direction is
- * roughly the separating axis, and next frame's first iteration
- * detects separation immediately.
- *
- * Writeback is automatic — `gjk_core` mutates a `subarray` view of
- * `axis_buffer`, so on return `axis_buffer[axis_offset..+2]` holds the
- * final direction. No try/finally needed.
- *
- * @param {number[]|Float64Array} simplex
- * @param {AbstractShape3D} shape_a
- * @param {AbstractShape3D} shape_b
- * @param {Float64Array} axis_buffer
- * @param {number} axis_offset
- * @returns {boolean}
- */
-export function gjk_with_axis(simplex: number[] | Float64Array, shape_a: AbstractShape3D, shape_b: AbstractShape3D, axis_buffer: Float64Array, axis_offset: number): boolean;
 //# sourceMappingURL=gjk.d.ts.map

package/src/engine/physics/gjk/gjk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gjk.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;GAaG;AACH,6BALW,MAAM,EAAE,GAAC,YAAY,uDAGnB,OAAO,CAWnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,uCAPW,MAAM,EAAE,GAAC,YAAY,mEAGrB,YAAY,eACZ,MAAM,GACJ,OAAO,CAqBnB"}
+{"version":3,"file":"gjk.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;GAaG;AACH,6BALW,MAAM,EAAE,GAAC,YAAY,uDAGnB,OAAO,CAWnB"}

package/src/engine/physics/gjk/gjk.js

@@ -40,60 +40,11 @@ export function gjk(simplex, shape_a, shape_b) {
     return gjk_core(simplex, shape_a, shape_b, scratch_dir);
 }
 
-/**
- * Separating-axis-cached variant of {@link gjk}. The 3 floats at
- * `axis_buffer[axis_offset..+2]` are used as the initial search
- * direction (seed) AND are overwritten with the final search direction
- * on exit. The narrowphase keeps a per-manifold-slot cache of these
- * three floats so quiescent contacts converge in 1–2 iterations next
- * frame instead of ~6–10 from a cold `(1, 0, 0)` start (Bullet's
- * `m_cachedSeparatingAxis` and Jolt's `ioV` use the same pattern).
- *
- * The same primitive doubles as a separating-axis cache for the
- * "no-overlap" path: when GJK returns false, the final direction is
- * roughly the separating axis, and next frame's first iteration
- * detects separation immediately.
- *
- * Writeback is automatic — `gjk_core` mutates a `subarray` view of
- * `axis_buffer`, so on return `axis_buffer[axis_offset..+2]` holds the
- * final direction. No try/finally needed.
- *
- * @param {number[]|Float64Array} simplex
- * @param {AbstractShape3D} shape_a
- * @param {AbstractShape3D} shape_b
- * @param {Float64Array} axis_buffer
- * @param {number} axis_offset
- * @returns {boolean}
- */
-export function gjk_with_axis(simplex, shape_a, shape_b, axis_buffer, axis_offset) {
-    // Subarray view: zero-copy in V8 once the JIT realises both views
-    // back the same buffer; the in-place writes inside gjk_core
-    // propagate to axis_buffer automatically.
-    const dir_view = axis_buffer.subarray(axis_offset, axis_offset + 3);
-
-    // Guard against a stale or degenerate cached axis. A zero vector
-    // (first-frame initial state, or a stuck cache) and NaN / Inf
-    // would crash the first support-point query; the (1, 0, 0)
-    // fallback is the cold-start default.
-    const x = dir_view[0], y = dir_view[1], z = dir_view[2];
-    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)
-        || (x === 0 && y === 0 && z === 0)) {
-        dir_view[0] = 1;
-        dir_view[1] = 0;
-        dir_view[2] = 0;
-    }
-
-    return gjk_core(simplex, shape_a, shape_b, dir_view);
-}
-
 /**
  * Core GJK routine — parameterised on the search-direction buffer.
- * The caller seeds `dir[0..2]` with an initial direction (typically
- * `(1, 0, 0)` for cold starts or a cached separating axis from a
- * previous frame), and on return `dir` holds the FINAL search
- * direction the algorithm settled on. The narrowphase separating-
- * axis cache (P2.1) uses this to thread per-manifold axes through
- * `gjk_with_axis` without a try/finally writeback dance.
+ * The caller seeds `dir[0..2]` with an initial direction (`(1, 0, 0)`
+ * for the {@link gjk} cold-start wrapper), and on return `dir` holds the
+ * FINAL search direction the algorithm settled on.
  *
  * @param {number[]|Float64Array} simplex
  * @param {AbstractShape3D} shape_a

package/src/engine/physics/gjk/gjk_epa_penetration.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Penetration depth + normal between two convex support providers at world pose.
+ * Writes the unit separation normal (B→A) into `out` and returns the depth
+ * (positive on overlap, 0 if separated — `out` untouched on 0).
+ *
+ * @param {Float64Array|number[]} out destination for the unit normal, length ≥ 3
+ * @param {SupportProvider} A world-space support provider (e.g. PosedShape)
+ * @param {SupportProvider} B world-space support provider (e.g. PosedShape)
+ * @returns {number} penetration depth, or 0 if separated
+ */
+export function gjk_epa_penetration(out: Float64Array | number[], A: SupportProvider, B: SupportProvider): number;
+/**
+ * A convex shape exposing a world-space support mapping: `support(out, off, dx,
+ * dy, dz)` writes the farthest point of the shape in direction `(dx, dy, dz)`
+ * into `out[off..off+2]` (e.g. {@link PosedShape }).
+ */
+export type SupportProvider = {
+    support: (arg0: Float64Array, arg1: number, arg2: number, arg3: number, arg4: number) => void;
+};
+//# sourceMappingURL=gjk_epa_penetration.d.ts.map

package/src/engine/physics/gjk/gjk_epa_penetration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAmhBA;;;;;;;;;GASG;AACH,yCALW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CAQlB;;;;;;8BAndY;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}