@woosh/meep-engine 2.133.3 → 2.134.0

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

@@ -0,0 +1,378 @@
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+
+const GJK_MAX_ITERATIONS = 64;
+
+/**
+ * Module-level scratch buffers to avoid per-call allocations.
+ */
+const scratch_support_a = new Float32Array(3);
+const scratch_support_b = new Float32Array(3);
+const scratch_dir = new Float32Array(3);
+
+/**
+ * Compute the Minkowski difference support point for two shapes.
+ * support(A-B, d) = support(A, d) - support(B, -d)
+ *
+ * The direction is normalized before being passed to the shape support
+ * functions, since {@link AbstractShape3D#support} assumes a unit vector.
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @param {number} dir_x
+ * @param {number} dir_y
+ * @param {number} dir_z
+ */
+function minkowski_support(
+    result, result_offset,
+    shape_a,
+    shape_b,
+    dir_x, dir_y, dir_z
+) {
+    // Normalize direction — support() contract requires a unit vector
+    const len = v3_length(dir_x, dir_y, dir_z);
+
+    if (len > 0) {
+        const inv = 1 / len;
+        dir_x *= inv;
+        dir_y *= inv;
+        dir_z *= inv;
+    }
+
+    shape_a.support(scratch_support_a, 0, dir_x, dir_y, dir_z);
+    shape_b.support(scratch_support_b, 0, -dir_x, -dir_y, -dir_z);
+
+    result[result_offset] = scratch_support_a[0] - scratch_support_b[0];
+    result[result_offset + 1] = scratch_support_a[1] - scratch_support_b[1];
+    result[result_offset + 2] = scratch_support_a[2] - scratch_support_b[2];
+}
+
+/**
+ * GJK intersection test for two convex shapes.
+ *
+ * Determines whether two convex shapes overlap by iteratively building a simplex
+ * in the Minkowski difference space. If the origin is enclosed by the simplex,
+ * the shapes intersect.
+ *
+ * Adapted from https://github.com/kevinmoran/GJK/blob/master/GJK.h
+ *
+ * @param {number[]|Float32Array} simplex Working buffer for simplex vertices (4 vec3s). Must have length >= 12.
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @returns {boolean} true if the shapes intersect
+ */
+export function gjk(simplex, shape_a, shape_b) {
+
+    const dir = scratch_dir;
+
+    // Initial search direction — arbitrary, (1,0,0)
+
+    // Get initial support point (simplex point C)
+    minkowski_support(
+        simplex, 6,
+        shape_a, shape_b,
+        1, 0, 0
+    );
+
+    // Search toward the origin from C
+    dir[0] = -simplex[6];
+    dir[1] = -simplex[7];
+    dir[2] = -simplex[8];
+
+    if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+        // Origin is exactly on the first support point — intersection
+        return true;
+    }
+
+    // Get second support point (simplex point B)
+    minkowski_support(simplex, 3, shape_a, shape_b, dir[0], dir[1], dir[2]);
+
+    // B didn't pass the origin — no intersection possible
+    if (v3_dot(simplex[3], simplex[4], simplex[5], dir[0], dir[1], dir[2]) < 0) {
+        return false;
+    }
+
+    // Line case: compute direction perpendicular to line segment BC toward origin
+    // CB = C - B
+    const cb_x = simplex[6] - simplex[3];
+    const cb_y = simplex[7] - simplex[4];
+    const cb_z = simplex[8] - simplex[5];
+
+    // BO = -B (origin - B)
+    const bo_x = -simplex[3];
+    const bo_y = -simplex[4];
+    const bo_z = -simplex[5];
+
+    // dir = CB × BO × CB (triple cross product)
+    triple_cross_product(dir, cb_x, cb_y, cb_z, bo_x, bo_y, bo_z);
+
+    // Handle degenerate case where origin is on the line segment
+    if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+        // Origin is on the line segment — pick any perpendicular direction
+        // Use the cross product of CB with an arbitrary axis
+        // CB × (1,0,0)
+        dir[0] = cb_y;
+        dir[1] = -cb_x;
+        dir[2] = 0;
+
+        if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+            // CB is parallel to (1,0,0), use (0,1,0)
+            dir[0] = -cb_z;
+            dir[1] = 0;
+            dir[2] = cb_x;
+        }
+    }
+
+    let simplex_size = 2; // we have B and C
+
+    for (let iterations = 0; iterations < GJK_MAX_ITERATIONS; iterations++) {
+        // Get new support point A
+        minkowski_support(simplex, 0, shape_a, shape_b, dir[0], dir[1], dir[2]);
+
+        const a_x = simplex[0];
+        const a_y = simplex[1];
+        const a_z = simplex[2];
+
+        // Check if A passed the origin
+        if (v3_dot(a_x, a_y, a_z, dir[0], dir[1], dir[2]) < 0) {
+            return false; // no intersection
+        }
+
+        simplex_size++;
+
+        if (simplex_size === 3) {
+            // Triangle case
+            update_simplex_triangle(dir, simplex);
+        } else {
+            // Tetrahedron case
+            if (update_simplex_tetrahedron(dir, simplex)) {
+                // Origin is inside the tetrahedron — intersection!
+                return true;
+            }
+
+            // The simplex was reduced to a triangle, so keep size at 3
+            simplex_size = 3;
+        }
+    }
+
+    // Did not converge — assume no intersection
+    return false;
+}
+
+/**
+ * Compute the triple cross product: (a × b) × a
+ *
+ * @param {number[]|Float32Array} result output vec3
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ */
+function triple_cross_product(result, ax, ay, az, bx, by, bz) {
+    // First: t = a × b
+    const tx = ay * bz - az * by;
+    const ty = az * bx - ax * bz;
+    const tz = ax * by - ay * bx;
+
+    // Then: t × a
+    result[0] = ty * az - tz * ay;
+    result[1] = tz * ax - tx * az;
+    result[2] = tx * ay - ty * ax;
+}
+
+/**
+ * Update simplex for the triangle case (3 points: A, B, C).
+ *
+ * Determines the Voronoi region of the origin relative to triangle ABC
+ * and updates the search direction accordingly.
+ *
+ * simplex layout: [A(0-2), B(3-5), C(6-8)]
+ *
+ * @param {number[]|Float32Array} search_dir output: next search direction
+ * @param {Float32Array} simplex
+ */
+function update_simplex_triangle(search_dir, simplex) {
+    const a_x = simplex[0], a_y = simplex[1], a_z = simplex[2];
+    const b_x = simplex[3], b_y = simplex[4], b_z = simplex[5];
+    const c_x = simplex[6], c_y = simplex[7], c_z = simplex[8];
+
+    // AB = B - A
+    const ab_x = b_x - a_x;
+    const ab_y = b_y - a_y;
+    const ab_z = b_z - a_z;
+
+    // AC = C - A
+    const ac_x = c_x - a_x;
+    const ac_y = c_y - a_y;
+    const ac_z = c_z - a_z;
+
+    // AO = -A (origin - A)
+    const ao_x = -a_x;
+    const ao_y = -a_y;
+    const ao_z = -a_z;
+
+    // Normal of triangle ABC
+    const abc_x = ab_y * ac_z - ab_z * ac_y;
+    const abc_y = ab_z * ac_x - ab_x * ac_z;
+    const abc_z = ab_x * ac_y - ab_y * ac_x;
+
+    // Test edge AC
+    // ABC × AC
+    const abc_cross_ac_x = abc_y * ac_z - abc_z * ac_y;
+    const abc_cross_ac_y = abc_z * ac_x - abc_x * ac_z;
+    const abc_cross_ac_z = abc_x * ac_y - abc_y * ac_x;
+
+    if (v3_dot(abc_cross_ac_x, abc_cross_ac_y, abc_cross_ac_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is on the AC side
+        // Reduce simplex to line AC (A stays as A, C moves to B position)
+        simplex[3] = c_x;
+        simplex[4] = c_y;
+        simplex[5] = c_z;
+
+        // New direction: AC × AO × AC
+        triple_cross_product(search_dir, ac_x, ac_y, ac_z, ao_x, ao_y, ao_z);
+        return;
+    }
+
+    // Test edge AB
+    // AB × ABC
+    const ab_cross_abc_x = ab_y * abc_z - ab_z * abc_y;
+    const ab_cross_abc_y = ab_z * abc_x - ab_x * abc_z;
+    const ab_cross_abc_z = ab_x * abc_y - ab_y * abc_x;
+
+    if (v3_dot(ab_cross_abc_x, ab_cross_abc_y, ab_cross_abc_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is on the AB side
+        // Keep simplex as line AB (C slot is cleared by not using it)
+        simplex[6] = simplex[3];
+        simplex[7] = simplex[4];
+        simplex[8] = simplex[5];
+
+        // New direction: AB × AO × AB
+        triple_cross_product(search_dir, ab_x, ab_y, ab_z, ao_x, ao_y, ao_z);
+        return;
+    }
+
+    // Origin is above or below the triangle
+    if (v3_dot(abc_x, abc_y, abc_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is above — search in normal direction
+        // Simplex stays as A, B, C
+        search_dir[0] = abc_x;
+        search_dir[1] = abc_y;
+        search_dir[2] = abc_z;
+    } else {
+        // Origin is below — swap B and C, search in -normal
+        const tmp_x = simplex[3], tmp_y = simplex[4], tmp_z = simplex[5];
+        simplex[3] = simplex[6];
+        simplex[4] = simplex[7];
+        simplex[5] = simplex[8];
+        simplex[6] = tmp_x;
+        simplex[7] = tmp_y;
+        simplex[8] = tmp_z;
+
+        search_dir[0] = -abc_x;
+        search_dir[1] = -abc_y;
+        search_dir[2] = -abc_z;
+    }
+}
+
+/**
+ * Update simplex for the tetrahedron case (4 points: A, B, C, D).
+ *
+ * Tests which face of the tetrahedron is closest to the origin and
+ * reduces the simplex accordingly. Returns true if the origin is
+ * inside the tetrahedron.
+ *
+ * simplex layout: [A(0-2), B(3-5), C(6-8), D(9-11)]
+ *
+ * @param {number[]|Float32Array} search_dir output: next search direction (only written when returning false)
+ * @param {Float32Array} simplex
+ * @returns {boolean} true if origin is inside the tetrahedron
+ */
+function update_simplex_tetrahedron(search_dir, simplex) {
+    const a_x = simplex[0], a_y = simplex[1], a_z = simplex[2];
+    const b_x = simplex[3], b_y = simplex[4], b_z = simplex[5];
+    const c_x = simplex[6], c_y = simplex[7], c_z = simplex[8];
+    const d_x = simplex[9], d_y = simplex[10], d_z = simplex[11];
+
+    // AB, AC, AD vectors
+    const ab_x = b_x - a_x, ab_y = b_y - a_y, ab_z = b_z - a_z;
+    const ac_x = c_x - a_x, ac_y = c_y - a_y, ac_z = c_z - a_z;
+    const ad_x = d_x - a_x, ad_y = d_y - a_y, ad_z = d_z - a_z;
+
+    // AO = origin - A = -A
+    const ao_x = -a_x, ao_y = -a_y, ao_z = -a_z;
+
+    // Face normals (outward-facing from A's perspective)
+    // ABC normal
+    const abc_x = ab_y * ac_z - ab_z * ac_y;
+    const abc_y = ab_z * ac_x - ab_x * ac_z;
+    const abc_z = ab_x * ac_y - ab_y * ac_x;
+
+    // ACD normal
+    const acd_x = ac_y * ad_z - ac_z * ad_y;
+    const acd_y = ac_z * ad_x - ac_x * ad_z;
+    const acd_z = ac_x * ad_y - ac_y * ad_x;
+
+    // ADB normal
+    const adb_x = ad_y * ab_z - ad_z * ab_y;
+    const adb_y = ad_z * ab_x - ad_x * ab_z;
+    const adb_z = ad_x * ab_y - ad_y * ab_x;
+
+    // Test each face to see if the origin is on the outside
+
+    // Check face ABC (opposite to D)
+    const abc_test = v3_dot(abc_x, abc_y, abc_z, ao_x, ao_y, ao_z);
+    // Make sure normal points away from D
+    const abc_d_side = v3_dot(abc_x, abc_y, abc_z, ad_x, ad_y, ad_z);
+
+    if (abc_test * abc_d_side < 0) {
+        // Origin is on the opposite side of ABC from D
+        // Reduce to triangle ABC: D is dropped
+        // simplex = [A, B, C] — A(0), B(3), C(6) already in place
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Check face ACD (opposite to B)
+    const acd_test = v3_dot(acd_x, acd_y, acd_z, ao_x, ao_y, ao_z);
+    const acd_b_side = v3_dot(acd_x, acd_y, acd_z, ab_x, ab_y, ab_z);
+
+    if (acd_test * acd_b_side < 0) {
+        // Origin is outside face ACD
+        // Reduce to triangle ACD: replace B with D
+        simplex[3] = c_x;
+        simplex[4] = c_y;
+        simplex[5] = c_z;
+        simplex[6] = d_x;
+        simplex[7] = d_y;
+        simplex[8] = d_z;
+
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Check face ADB (opposite to C)
+    const adb_test = v3_dot(adb_x, adb_y, adb_z, ao_x, ao_y, ao_z);
+    const adb_c_side = v3_dot(adb_x, adb_y, adb_z, ac_x, ac_y, ac_z);
+
+    if (adb_test * adb_c_side < 0) {
+        // Origin is outside face ADB
+        // Reduce to triangle ADB: replace C with B, B with D
+        simplex[6] = b_x;
+        simplex[7] = b_y;
+        simplex[8] = b_z;
+        simplex[3] = d_x;
+        simplex[4] = d_y;
+        simplex[5] = d_z;
+
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Origin is inside the tetrahedron
+    return true;
+}

package/src/core/geom/3d/topology/simplify/quadratic/Quadratic3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Quadratic3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/Quadratic3.js"],"names":[],"mappings":"AASA;;;GAGG;AACH;IAGI,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAGP,WAAO;IACP,WAAO;IACP,WAAO;IAGP,WAAO;IACP,WAAO;IAGP,WAAO;IAGP;;;OAGG;IACH,kBAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAMjD;IAED;;;OAGG;IACH,eAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAcjD;IAED;;;;;OAKG;IACH,sBAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,WACvC,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;OAGG;IACH,sCAmBC;IAED;;;;;;OAMG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED;;;;;;;OAOG;IACH,cAHW,MAAM,EAAE,GACN,OAAO,CAgBnB;IAED;;;OAGG;IACH,OAFW,UAAU,QAuBpB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,SAFa,UAAU,CAQtB;IAED;;;OAGG;IACH,YAFW,UAAU,QAqBpB;IAED;;OAEG;IACH,cAmBC;CACJ"}

package/src/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,302 +0,0 @@
-import { vec3 } from "gl-matrix";
-import { EPSILON } from "../../../../../math/EPSILON.js";
-import { fabsf } from "../../../../../math/fabsf.js";
-import { v3_dot } from "../../../../vec3/v3_dot.js";
-import { compute_triangle_normal } from "../../../triangle/compute_triangle_normal.js";
-
-const scratch_v3 = new Float32Array(3);
-const scratch_m3 = new Float32Array(9);
-
-/**
- * Quadric Error Metric
- * Triangular 4x4 matrix, see https://en.wikipedia.org/wiki/Triangular_matrix
- */
-export class Quadratic3 {
-
-    // Row 0
-    a2 = 0;
-    ab = 0;
-    ac = 0;
-    ad = 0;
-
-    // Row 1
-    b2 = 0;
-    bc = 0;
-    bd = 0;
-
-    // Row 2
-    c2 = 0;
-    cd = 0;
-
-    // Row 3
-    d2 = 0;
-
-
-    /**
-     *
-     * @param {ArrayLike<number>|number[]|Float32Array} result
-     */
-    toVector3(result) {
-        result[0] = this.ad;
-        result[1] = this.bd;
-        result[2] = this.cd;
-    }
-
-    /**
-     *
-     * @param {ArrayLike<number>|number[]|Float32Array} m3
-     */
-    toTensorM3(m3) {
-        m3[0] = this.a2;
-        m3[1] = this.ab;
-        m3[2] = this.ac;
-
-        m3[3] = this.ab;
-        m3[4] = this.b2;
-        m3[5] = this.bc;
-
-        m3[6] = this.ac;
-        m3[7] = this.bc;
-        m3[8] = this.c2;
-    }
-
-    /**
-     * Equivalent to taking a tensor followed by matrix inversion
-     * @param {ArrayLike<number>|number[]|Float32Array} m3
-     * @param {number} epsilon
-     * @returns {boolean} whether operation was successful or not
-     */
-    toTensorM3Inverse(m3, epsilon) {
-        const a2 = this.a2;
-        const b2 = this.b2;
-        const c2 = this.c2;
-        const bc = this.bc;
-        const ab = this.ab;
-        const ac = this.ac;
-
-        const det = a2 * (b2 * c2 - bc * bc) -
-            ab * (ab * c2 - ac * bc) +
-            ac * (ab * bc - ac * b2);
-
-        if (fabsf(det) > epsilon) {
-
-            const invdet = 1.0 / det;
-
-            m3[0] = (b2 * c2 - bc * bc) * invdet;
-            m3[3] = (bc * ac - ab * c2) * invdet;
-            m3[6] = (ab * bc - b2 * ac) * invdet;
-
-            m3[1] = (ac * bc - ab * c2) * invdet;
-            m3[4] = (a2 * c2 - ac * ac) * invdet;
-            m3[7] = (ab * ac - a2 * bc) * invdet;
-
-            m3[2] = (ab * bc - ac * b2) * invdet;
-            m3[5] = (ac * ab - a2 * bc) * invdet;
-            m3[8] = (a2 * b2 - ab * ab) * invdet;
-
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Set from plane expressed as a 4 component vector
-     * @param {number} x plane normal
-     * @param {number} y plane normal
-     * @param {number} z plane normal
-     * @param {number} w plane offset
-     */
-    setFromVector4(x, y, z, w) {
-        this.a2 = x * x;
-        this.ab = x * y;
-        this.ac = x * z;
-        this.ad = x * w;
-
-        this.b2 = y * y;
-        this.bc = y * z;
-        this.bd = y * w;
-
-        this.c2 = z * z;
-        this.cd = z * w;
-
-        this.d2 = w * w;
-    }
-
-    /**
-     *
-     * @param {TopoTriangle} face
-     */
-    setFromFace(face) {
-        const v0 = face.vertices[0];
-
-        // compute triangle's plane
-        compute_triangle_normal(scratch_v3, v0, face.vertices[1], face.vertices[2]);
-
-        // compute plane offset
-
-        const normal_x = scratch_v3[0];
-        const normal_y = scratch_v3[1];
-        const normal_z = scratch_v3[2];
-
-        const plane_constant = -v3_dot(
-            normal_x, normal_y, normal_z,
-
-            v0.x, v0.y, v0.z
-        );
-
-        this.setFromVector4(normal_x, normal_y, normal_z, plane_constant);
-    }
-
-    /**
-     * Squared distance from the given point to plane encoded by the quadratic
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {number}
-     */
-    evaluate(x, y, z) {
-        // Evaluate vAv + 2bv + c
-
-        return (x * x * this.a2) + (2 * x * y * this.ab) + (2 * x * z * this.ac) + (2 * x * this.ad)    // A
-            + (y * y * this.b2) + (2 * y * z * this.bc) + (2 * y * this.bd)                             // B
-            + (z * z * this.c2) + (2 * z * this.cd)                                                     // C
-            + this.d2;                                                                                  // D
-    }
-
-    /**
-     * Find optimal vertex position based on the quadratic
-     *
-     * Based on Blender's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
-     *
-     * @param {number[]} out
-     * @returns {boolean}
-     */
-    optimize(out) {
-
-        if (this.toTensorM3Inverse(scratch_m3, EPSILON)) {
-
-            this.toVector3(out);
-
-            vec3.transformMat3(out, out, scratch_m3);
-            vec3.negate(out, out);
-
-            return true;
-        }
-
-        return false;
-
-    }
-
-    /**
-     *
-     * @param {Quadratic3} Q
-     */
-    add(Q) {
-
-        // Accumulate coefficients
-
-        // R0
-        this.a2 += Q.a2;
-        this.ab += Q.ab;
-        this.ac += Q.ac;
-        this.ad += Q.ad;
-
-        // R1
-        this.b2 += Q.b2;
-        this.bc += Q.bc;
-        this.bd += Q.bd;
-
-        // R2
-        this.c2 += Q.c2;
-        this.cd += Q.cd;
-
-        // R3
-        this.d2 += Q.d2;
-    }
-
-    /**
-     *
-     * @param {number} v
-     */
-    multiplyScalar(v) {
-        // R0
-        this.a2 *= v;
-        this.ab *= v;
-        this.ac *= v;
-        this.ad *= v;
-
-        // R1
-        this.b2 *= v;
-        this.bc *= v;
-        this.bd *= v;
-
-        // R2
-        this.c2 *= v;
-        this.cd *= v;
-
-        // R3
-        this.d2 *= v;
-    }
-
-    /**
-     *
-     * @returns {Quadratic3}
-     */
-    clone() {
-        const r = new Quadratic3();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {Quadratic3} other
-     */
-    copy(other) {
-
-        // R0
-        this.a2 = other.a2;
-        this.ab = other.ab;
-        this.ac = other.ac;
-        this.ad = other.ad;
-
-        // R1
-        this.b2 = other.b2;
-        this.bc = other.bc;
-        this.bd = other.bd;
-
-        // R2
-        this.c2 = other.c2;
-        this.cd = other.cd;
-
-        // R3
-        this.d2 = other.d2;
-    }
-
-    /**
-     * Set all matrix values to 0
-     */
-    clear() {
-        // Row 0
-        this.a2 = 0;
-        this.ab = 0;
-        this.ac = 0;
-        this.ad = 0;
-
-        // Row 1
-        this.b2 = 0;
-        this.bc = 0;
-        this.bd = 0;
-
-        // Row 2
-        this.c2 = 0;
-        this.cd = 0;
-
-        // Row 3
-        this.d2 = 0;
-
-    }
-}