@woosh/meep-engine 2.164.0 → 2.165.0

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js

@@ -0,0 +1,199 @@
+import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+import { ATLAS_SEGMENT_DEFAULTS } from "./atlas_segment_charts.js";
+
+// These mirror atlas_segment_charts (the face-granular twin); kept local so the
+// two segmenters stay monomorphic.
+const REJECT = Infinity;
+const NORMAL_DEVIATION_REJECT = 0.707;
+const STALE_EPSILON = 1e-6;
+
+/**
+ * Region-atomic chart segmentation (xatlas grows whole coplanar regions as
+ * units). Identical greedy structure and cost to {@link atlas_segment_charts},
+ * but the growth nodes are planar regions from {@link atlas_build_region_graph}
+ * rather than individual triangles: a chart absorbs an entire region at a time.
+ * This keeps coplanar faces together (no seam through a flat surface) and is
+ * far cheaper on flat-heavy meshes (the heap holds regions, not triangles).
+ *
+ * Cost = `normalDeviationWeight·N + normalSeamWeight·NS + roundnessWeight·R`,
+ * with the same 73-degree hard reject and optional area/boundary caps. The
+ * candidate queue uses the same lazy re-evaluation. Deterministic.
+ *
+ * @param {RegionGraph} region_graph from atlas_build_region_graph
+ * @param {Uint32Array} region_of_face face -> region id (NULL_POINTER if unallocated)
+ * @param {object} [options] overrides of ATLAS_SEGMENT_DEFAULTS
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_segment_charts_atomic(region_graph, region_of_face, options = {}) {
+    const opt = { ...ATLAS_SEGMENT_DEFAULTS, ...options };
+    const rg = region_graph;
+    const RC = rg.region_count;
+
+    const region_chart = new Int32Array(RC).fill(-1);
+    const region_cost = new Float32Array(RC);
+    const heap = new IndexedFloatMinHeap(Math.max(1, RC));
+
+    let chart_id = 0;
+    let chart_area = 0;
+    let chart_boundary = 0;
+    let accum_x = 0, accum_y = 0, accum_z = 0;
+
+    const cn = new Float32Array(3);
+    let out_area = 0;
+    let out_boundary = 0;
+
+    /**
+     * Normalize the chart's running area-weighted normal accumulator into `cn`.
+     */
+    function chart_unit_normal() {
+        const len = Math.sqrt(accum_x * accum_x + accum_y * accum_y + accum_z * accum_z) || 1;
+        cn[0] = accum_x / len;
+        cn[1] = accum_y / len;
+        cn[2] = accum_z / len;
+    }
+
+    /**
+     * Cost of adding region g to the current chart, or REJECT. Side effect: sets
+     * out_area / out_boundary for the caller to commit.
+     * @param {number} g region id
+     * @returns {number}
+     */
+    function evaluate(g) {
+        const gx = rg.region_normal[g * 3];
+        const gy = rg.region_normal[g * 3 + 1];
+        const gz = rg.region_normal[g * 3 + 2];
+        const glen = Math.sqrt(gx * gx + gy * gy + gz * gz) || 1;
+
+        chart_unit_normal();
+        const dot = (cn[0] * gx + cn[1] * gy + cn[2] * gz) / glen;
+        const N = Math.min(1 - dot, 1);
+        if (N >= NORMAL_DEVIATION_REJECT) {
+            return REJECT;
+        }
+
+        const new_area = chart_area + rg.region_area[g];
+        if (opt.maxChartArea > 0 && new_area > opt.maxChartArea) {
+            return REJECT;
+        }
+
+        let shared = 0;
+        let seam = 0;
+        const start = rg.offsets[g];
+        const end = rg.offsets[g + 1];
+        for (let k = start; k < end; k++) {
+            if (region_chart[rg.adj[k]] === chart_id) {
+                shared += rg.adj_shared[k];
+                seam += rg.adj_seam[k];
+            }
+        }
+
+        const new_boundary = chart_boundary + rg.region_boundary[g] - 2 * shared;
+        if (opt.maxBoundaryLength > 0 && new_boundary > opt.maxBoundaryLength) {
+            return REJECT;
+        }
+
+        const NS = shared > 0 ? seam / shared : 0;
+
+        let R = 0;
+        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
+            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
+            const new_ratio = (new_boundary * new_boundary) / new_area;
+            R = 1 - old_ratio / new_ratio;
+        }
+
+        out_area = new_area;
+        out_boundary = new_boundary;
+
+        return opt.normalDeviationWeight * N + opt.normalSeamWeight * NS + opt.roundnessWeight * R;
+    }
+
+    /**
+     * (Re-)evaluate and (re-)queue every unallocated region adjacent to r in the
+     * region graph, caching each candidate's cost in `region_cost`.
+     * @param {number} r region id just committed to the current chart
+     */
+    function push_neighbours(r) {
+        const start = rg.offsets[r];
+        const end = rg.offsets[r + 1];
+        for (let k = start; k < end; k++) {
+            const h = rg.adj[k];
+            if (region_chart[h] === -1) {
+                const c = evaluate(h);
+                if (c !== REJECT) {
+                    if (heap.contains(h)) {
+                        heap.update(h, c);
+                    } else {
+                        heap.insert(h, c);
+                    }
+                    region_cost[h] = c;
+                }
+            }
+        }
+    }
+
+    let chart_count = 0;
+
+    for (let seed = 0; seed < RC; seed++) {
+        if (region_chart[seed] !== -1) {
+            continue;
+        }
+
+        chart_id = chart_count;
+        chart_count++;
+        heap.clear();
+
+        region_chart[seed] = chart_id;
+        accum_x = rg.region_normal[seed * 3];
+        accum_y = rg.region_normal[seed * 3 + 1];
+        accum_z = rg.region_normal[seed * 3 + 2];
+        chart_area = rg.region_area[seed];
+        chart_boundary = rg.region_boundary[seed];
+
+        push_neighbours(seed);
+
+        for (;;) {
+            const g = heap.pop_min();
+            if (g === -1) {
+                break;
+            }
+            if (region_chart[g] !== -1) {
+                continue;
+            }
+
+            const stored = region_cost[g];
+            const fresh = evaluate(g);
+            if (fresh === REJECT) {
+                continue;
+            }
+            if (Math.abs(fresh - stored) > STALE_EPSILON) {
+                region_cost[g] = fresh;
+                heap.insert(g, fresh);
+                continue;
+            }
+            if (fresh > opt.maxCost) {
+                break;
+            }
+
+            region_chart[g] = chart_id;
+            chart_area = out_area;
+            chart_boundary = out_boundary;
+            accum_x += rg.region_normal[g * 3];
+            accum_y += rg.region_normal[g * 3 + 1];
+            accum_z += rg.region_normal[g * 3 + 2];
+
+            push_neighbours(g);
+        }
+    }
+
+    const face_count = region_of_face.length;
+    const face_chart = new Int32Array(face_count).fill(-1);
+    for (let f = 0; f < face_count; f++) {
+        const r = region_of_face[f];
+        if (r !== NULL_POINTER) {
+            face_chart[f] = region_chart[r];
+        }
+    }
+
+    return { face_chart, chart_count };
+}

package/src/core/geom/3d/line/line3_compute_point_segment_point_distance_unfolded.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shortest "bent string" from point P, touching the segment A->B, then continuing to point Q, with the
+ * two legs UNFOLDED flat across the segment's line. This is the 3D form of the classic 2D reflect-and-
+ * measure: reflect one point across the line carrying the segment, draw a straight chord; if that chord
+ * crosses the segment the chord length is the answer, otherwise the taut path bends around an endpoint.
+ *
+ * P and Q need not be coplanar with the segment. Each is decomposed against the segment's line into a
+ * tangential coordinate (along the line) and a perpendicular distance (to the line); the two perpendiculars
+ * are laid on opposite sides of the line (the fold), so the unfolded chord is well defined in 3D without
+ * any shared plane or global "up".
+ *
+ * Because it measures straight chords rather than an on-surface geodesic, the result is always <= the true
+ * across-the-edge geodesic distance -- i.e. it is an admissible lower bound (its use as the A* heuristic in
+ * navmesh path search). See also {@link line3_compute_segment_point_distance_eikonal} for the related
+ * wavefront-update primitive that takes seeded endpoint distances instead of a single source point.
+ *
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz first point (one leg's far end)
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az segment endpoint A
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz segment endpoint B
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz second point (other leg's far end)
+ * @returns {number} length of the shortest unfolded path P -> [A,B] -> Q
+ */
+export function line3_compute_point_segment_point_distance_unfolded(px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, qx: number, qy: number, qz: number): number;
+//# sourceMappingURL=line3_compute_point_segment_point_distance_unfolded.d.ts.map

package/src/core/geom/3d/line/line3_compute_point_segment_point_distance_unfolded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_point_segment_point_distance_unfolded.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_point_segment_point_distance_unfolded.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wEAdW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAmClB"}

package/src/core/geom/3d/line/line3_compute_point_segment_point_distance_unfolded.js

@@ -0,0 +1,64 @@
+/**
+ * Shortest "bent string" from point P, touching the segment A->B, then continuing to point Q, with the
+ * two legs UNFOLDED flat across the segment's line. This is the 3D form of the classic 2D reflect-and-
+ * measure: reflect one point across the line carrying the segment, draw a straight chord; if that chord
+ * crosses the segment the chord length is the answer, otherwise the taut path bends around an endpoint.
+ *
+ * P and Q need not be coplanar with the segment. Each is decomposed against the segment's line into a
+ * tangential coordinate (along the line) and a perpendicular distance (to the line); the two perpendiculars
+ * are laid on opposite sides of the line (the fold), so the unfolded chord is well defined in 3D without
+ * any shared plane or global "up".
+ *
+ * Because it measures straight chords rather than an on-surface geodesic, the result is always <= the true
+ * across-the-edge geodesic distance -- i.e. it is an admissible lower bound (its use as the A* heuristic in
+ * navmesh path search). See also {@link line3_compute_segment_point_distance_eikonal} for the related
+ * wavefront-update primitive that takes seeded endpoint distances instead of a single source point.
+ *
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz first point (one leg's far end)
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az segment endpoint A
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz segment endpoint B
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz second point (other leg's far end)
+ * @returns {number} length of the shortest unfolded path P -> [A,B] -> Q
+ */
+export function line3_compute_point_segment_point_distance_unfolded(
+    px, py, pz,
+    ax, ay, az,
+    bx, by, bz,
+    qx, qy, qz
+) {
+
+    const dx = bx - ax, dy = by - ay, dz = bz - az;
+    const dlen2 = dx * dx + dy * dy + dz * dz;
+    const viaA = Math.hypot(px - ax, py - ay, pz - az) + Math.hypot(qx - ax, qy - ay, qz - az);
+
+    if (dlen2 < 1e-18) {
+        // degenerate segment: A == B, so the only touch point is that vertex
+        return viaA;
+    }
+
+    const dlen = Math.sqrt(dlen2), ux = dx / dlen, uy = dy / dlen, uz = dz / dlen;
+    const pt = (px - ax) * ux + (py - ay) * uy + (pz - az) * uz;
+    const pperp = Math.hypot(px - ax - pt * ux, py - ay - pt * uy, pz - az - pt * uz);
+    const qt = (qx - ax) * ux + (qy - ay) * uy + (qz - az) * uz;
+    const qperp = Math.hypot(qx - ax - qt * ux, qy - ay - qt * uy, qz - az - qt * uz);
+
+    const denom = pperp + qperp;
+    const xs = denom < 1e-12 ? pt : pt + (qt - pt) * pperp / denom; // segment crossing of the unfolded line
+
+    if (xs >= 0 && xs <= dlen) {
+        // taut string passes through the segment interior: the answer is the unfolded chord length
+        return Math.hypot(qt - pt, denom);
+    }
+
+    // crossing falls outside the segment: the path must bend around the nearer endpoint
+    const viaB = Math.hypot(px - bx, py - by, pz - bz) + Math.hypot(qx - bx, qy - by, qz - bz);
+    return Math.min(viaA, viaB);
+}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a
+ * (non-uniform) scale. `out = T * R * S`.
+ *
+ * Array-argument companion to {@link m4_compose} (which takes `{x,y,z}` / `{x,y,z,w}`
+ * objects): use this when the operands are already laid out as flat arrays. Mirrors
+ * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
+ * unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`
+ * @param {number[]|Float32Array|Float64Array} v translation `[x, y, z]`
+ * @param {number[]|Float32Array|Float64Array} s scale `[x, y, z]`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale(out: number[] | Float32Array | Float64Array, q: number[] | Float32Array | Float64Array, v: number[] | Float32Array | Float64Array, s: number[] | Float32Array | Float64Array): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_from_rotation_translation_scale.d.ts.map

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_from_rotation_translation_scale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAoD9C"}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js

@@ -0,0 +1,66 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a
+ * (non-uniform) scale. `out = T * R * S`.
+ *
+ * Array-argument companion to {@link m4_compose} (which takes `{x,y,z}` / `{x,y,z,w}`
+ * objects): use this when the operands are already laid out as flat arrays. Mirrors
+ * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
+ * unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`
+ * @param {number[]|Float32Array|Float64Array} v translation `[x, y, z]`
+ * @param {number[]|Float32Array|Float64Array} s scale `[x, y, z]`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale(out, q, v, s) {
+    const x = q[0];
+    const y = q[1];
+    const z = q[2];
+    const w = q[3];
+
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+
+    const sx = s[0];
+    const sy = s[1];
+    const sz = s[2];
+
+    out[0] = (1 - (yy + zz)) * sx;
+    out[1] = (xy + wz) * sx;
+    out[2] = (xz - wy) * sx;
+    out[3] = 0;
+
+    out[4] = (xy - wz) * sy;
+    out[5] = (1 - (xx + zz)) * sy;
+    out[6] = (yz + wx) * sy;
+    out[7] = 0;
+
+    out[8] = (xz + wy) * sz;
+    out[9] = (yz - wx) * sz;
+    out[10] = (1 - (xx + yy)) * sz;
+    out[11] = 0;
+
+    out[12] = v[0];
+    out[13] = v[1];
+    out[14] = v[2];
+    out[15] = 1;
+
+    return out;
+}

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh3_dering_optimize_positive.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js"],"names":[],"mappings":"AAiTA;;;;;;;GAOG;AACH,qDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBAClC,MAAM,oBACN,MAAM,QAIhB"}
+{"version":3,"file":"sh3_dering_optimize_positive.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js"],"names":[],"mappings":"AAmTA;;;;;;;GAOG;AACH,qDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBAClC,MAAM,oBACN,MAAM,QAIhB"}

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -1,4 +1,6 @@
-import { mat3, vec3 } from "gl-matrix";
+import { v3_normalize_array } from "../../../vec3/v3_normalize_array.js";
+import { v3_negate_array } from "../../../vec3/v3_negate_array.js";
+import { v3_cross } from "../../../vec3/v3_cross.js";
 import { assert } from "../../../../assert.js";
 import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
@@ -56,21 +58,21 @@ function sh3_min(input_sh3) {
 
 
     // first this to do is to rotate the SH to align Z with the optimal linear direction
-    const dir = vec3.fromValues(-input_sh3[3], -input_sh3[1], input_sh3[2]);
+    const dir = Float32Array.of(-input_sh3[3], -input_sh3[1], input_sh3[2]);
 
-    vec3.normalize(dir, dir);
+    v3_normalize_array(dir, 0, dir, 0);
 
-    const z_axis = vec3.create();
-    vec3.negate(z_axis, dir);
+    const z_axis = new Float32Array(3);
+    v3_negate_array(z_axis, 0, dir, 0);
 
-    const x_axis = vec3.create();
-    vec3.cross(x_axis, z_axis, vec3.fromValues(0, 1, 0));
-    vec3.normalize(x_axis, x_axis);
+    const x_axis = new Float32Array(3);
+    v3_cross(x_axis, 0, z_axis[0], z_axis[1], z_axis[2], 0, 1, 0);
+    v3_normalize_array(x_axis, 0, x_axis, 0);
 
-    const y_axis = vec3.create();
-    vec3.cross(y_axis, x_axis, z_axis);
+    const y_axis = new Float32Array(3);
+    v3_cross(y_axis, 0, x_axis[0], x_axis[1], x_axis[2], z_axis[0], z_axis[1], z_axis[2]);
 
-    const M = mat3.create();
+    const M = new Float32Array(9);
     array_copy(x_axis, 0, M, 0, 3);
     array_copy(y_axis, 0, M, 3, 3);
     array_copy(dir, 0, M, 6, 3);

package/src/core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphere_compute_bounding_of_2_spheres.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,6DAJW,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,QAoDpC"}
+{"version":3,"file":"sphere_compute_bounding_of_2_spheres.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,6DAJW,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,QAoDpC"}

package/src/core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.js

@@ -1,7 +1,8 @@
 //
 
 
-import { vec3 } from "gl-matrix";
+import { v3_subtract } from "../../vec3/v3_subtract.js";
+import { v3_normalize_array } from "../../vec3/v3_normalize_array.js";
 import { max2 } from "../../../math/max2.js";
 import { Miniball } from "../../packing/miniball/Miniball.js";
 import { PointSet } from "../../packing/miniball/PointSet.js";
@@ -23,7 +24,7 @@ const outer_points = new Float32Array(12);
  */
 export function sphere_compute_bounding_of_2_spheres(result, a, b) {
     // compute distance between the spheres
-    vec3.sub(delta_direction, a, b);
+    v3_subtract(delta_direction, 0, a[0], a[1], a[2], b[0], b[1], b[2]);
 
     if (delta_direction[0] === 0 && delta_direction[1] === 0 && delta_direction[2] === 0) {
         // sphere centers overlap
@@ -34,7 +35,7 @@ export function sphere_compute_bounding_of_2_spheres(result, a, b) {
         return;
     }
 
-    vec3.normalize(delta_direction, delta_direction);
+    v3_normalize_array(delta_direction, 0, delta_direction, 0);
 
     // compute outer points on the spheres along the line between their centers
     const a_radius = a[3];

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

@@ -1 +1 @@
-{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,WAAU,yCAEpB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB"}
+{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,WAAU,yCAEpB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB"}

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js

@@ -1,4 +1,5 @@
-import { vec3 } from "gl-matrix";
+import { v3_distance_sqr } from "../../../vec3/v3_distance_sqr.js";
+import { v3_dot } from "../../../vec3/v3_dot.js";
 import { array_get_index_in_range } from "../../../../collection/array/array_get_index_in_range.js";
 import { EPSILON } from "../../../../math/EPSILON.js";
 import { min2 } from "../../../../math/min2.js";
@@ -119,9 +120,9 @@ function build_edge_cost_squared_topology(edge) {
     tm_vertex_compute_normal(scratch_v3_0, 0, edge.v0);
     tm_vertex_compute_normal(scratch_v3_1, 0, edge.v1);
 
-    const distance_sqr = vec3.squaredDistance(edge.v0, edge.v1);
+    const distance_sqr = v3_distance_sqr(edge.v0.x, edge.v0.y, edge.v0.z, edge.v1.x, edge.v1.y, edge.v1.z);
 
-    let cost = Math.abs(vec3.dot(scratch_v3_0, scratch_v3_1))
+    let cost = Math.abs(v3_dot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2], scratch_v3_1[0], scratch_v3_1[1], scratch_v3_1[2]))
         / min2(-distance_sqr, -EPSILON);
 
     return cost;

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

@@ -1 +1 @@
-{"version":3,"file":"Quadric3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/Quadric3.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IACI,cAEC;IAMD,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAGf;;;OAGG;IACH,kBAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAMjD;IAED;;;OAGG;IACH,eAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAkBjD;IAED;;;;;OAKG;IACH,sBAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,WACvC,MAAM,GACJ,OAAO,CAqCnB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED;;;;;OAKG;IACH,cAHW,MAAM,EAAE,GACN,OAAO,CAkBnB;IAED;;;OAGG;IACH,OAFW,QAAQ,QAalB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAahB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAQpB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAIlB;IAED;;OAEG;IACH,cAEC;IAGL;;;;OAIG;IACH,qBAFU,OAAO,CAEY;CAP5B"}
+{"version":3,"file":"Quadric3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/Quadric3.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH;IACI,cAEC;IAMD,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAGf;;;OAGG;IACH,kBAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAMjD;IAED;;;OAGG;IACH,eAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAkBjD;IAED;;;;;OAKG;IACH,sBAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,WACvC,MAAM,GACJ,OAAO,CAqCnB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED;;;;;OAKG;IACH,cAHW,MAAM,EAAE,GACN,OAAO,CAkBnB;IAED;;;OAGG;IACH,OAFW,QAAQ,QAalB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAahB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAQpB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAIlB;IAED;;OAEG;IACH,cAEC;IAGL;;;;OAIG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

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

@@ -1,4 +1,5 @@
-import { vec3 } from "gl-matrix";
+import { v3_matrix3_multiply } from "../../../../vec3/v3_matrix3_multiply.js";
+import { v3_negate_array } from "../../../../vec3/v3_negate_array.js";
 import { EPSILON } from "../../../../../math/EPSILON.js";
 
 const scratch_m3 = new Float32Array(9);
@@ -226,8 +227,8 @@ export class Quadric3 extends Float64Array {
 
             this.toVector3(out);
 
-            vec3.transformMat3(out, out, scratch_m3);
-            vec3.negate(out, out);
+            v3_matrix3_multiply(out, 0, out, 0, scratch_m3);
+            v3_negate_array(out, 0, out, 0);
 
             return true;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"apply_border_penalty_to_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/apply_border_penalty_to_vertex_quadrics.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,gFAHW,MAAM,mBACN,IAAI,MAAM,EAAE,QAAQ,CAAC,QAoC/B;yBA3CwB,eAAe"}
+{"version":3,"file":"apply_border_penalty_to_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/apply_border_penalty_to_vertex_quadrics.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,gFAHW,MAAM,mBACN,IAAI,MAAM,EAAE,QAAQ,CAAC,QAoC/B;yBA3CwB,eAAe"}

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

@@ -1,4 +1,8 @@
-import { vec3 } from "gl-matrix";
+import { v3_subtract } from "../../../../vec3/v3_subtract.js";
+import { v3_cross } from "../../../../vec3/v3_cross.js";
+import { v3_normalize_array } from "../../../../vec3/v3_normalize_array.js";
+import { v3_dot } from "../../../../vec3/v3_dot.js";
+import { v3_length } from "../../../../vec3/v3_length.js";
 import { assert } from "../../../../../assert.js";
 import { tm_face_normal } from "../../tm_face_normal.js";
 import { Quadric3 } from "./Quadric3.js";
@@ -15,7 +19,7 @@ export function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_qua
     const v1 = edge.v1;
 
     const edge_vector = [];
-    vec3.sub(edge_vector, v0, v1);
+    v3_subtract(edge_vector, 0, v0.x, v0.y, v0.z, v1.x, v1.y, v1.z);
 
     // Edge must have exactly 1 triangle attached
     const edge_faces = edge.faces;
@@ -29,14 +33,14 @@ export function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_qua
 
     const abc = [];
 
-    vec3.cross(abc, edge_vector, normal);
-    vec3.normalize(abc, abc);
+    v3_cross(abc, 0, edge_vector[0], edge_vector[1], edge_vector[2], normal[0], normal[1], normal[2]);
+    v3_normalize_array(abc, 0, abc, 0);
 
-    const d = -vec3.dot(abc, v0);
+    const d = -v3_dot(abc[0], abc[1], abc[2], v0.x, v0.y, v0.z);
 
     const constraint = new Quadric3();
     constraint.setFromVector4(abc[0], abc[1], abc[2], d);
-    constraint.multiplyScalar(vec3.length(edge_vector) * weight);
+    constraint.multiplyScalar(v3_length(edge_vector[0], edge_vector[1], edge_vector[2]) * weight);
 
     // apply constraint
     const v0_quadric = vertex_quadrics.get(v0.index);

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -1,4 +1,4 @@
-import { vec3 } from "gl-matrix";
+import { v3_copy_array } from "../../../vec3/v3_copy_array.js";
 import { assert } from "../../../../assert.js";
 import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
 import { noop } from "../../../../function/noop.js";
@@ -267,7 +267,7 @@ export class TopoMesh {
         const f = new TopoTriangle();
 
         // copy face normal
-        vec3.copy(f.normal, face.normal);
+        v3_copy_array(f.normal, 0, face.normal, 0);
 
         const face_vertices = face.vertices;
 

package/src/core/geom/3d/topology/struct/TopoTriangle.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="gl-matrix/index.js" />
 export class TopoTriangle {
     /**
      * Utility constructor
@@ -122,5 +121,4 @@ export class TopoTriangle {
 }
 import { TopoVertex } from "./TopoVertex.js";
 import { TopoEdge } from "./TopoEdge.js";
-import { vec3 } from "gl-matrix";
 //# sourceMappingURL=TopoTriangle.d.ts.map

package/src/core/geom/3d/topology/struct/TopoTriangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopoTriangle.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoTriangle.js"],"names":[],"mappings":";AAWA;IAmRI;;;;;;;;;;;;OAYG;IACH,sBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,CA4CvB;IAzUD;;;OAGG;IACH,OAFU,MAAM,CAEQ;IACxB;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IACd;;;OAGG;IACH,OAFU,QAAQ,EAAE,CAET;IAEX;;;OAGG;IACH,QAFU,MAAM,EAAE,GAAC,IAAI,CAEJ;IAEnB,uBAEC;IAED;;;OAGG;IACH,YAFW,YAAY,QAQtB;IAED,sBAMC;IAED;;;;OAIG;IACH,+BAFY,OAAO,CA0ClB;IAED;;;OAGG;IACH,YAFY,OAAO,CAKlB;IAED;;;;OAIG;IACH,sBAHW,QAAQ,eACR,QAAQ,QAIlB;IAED;;;;OAIG;IACH,wBAHW,UAAU,eACV,UAAU,QAMpB;IAED;;OAEG;IACH,gCASC;IAED;;OAEG;IACH,eAmBC;IAED;;;OAGG;IACH,WAFW,QAAQ,QAMlB;IAED;;;;OAIG;IACH,iBAHW,QAAQ,GACP,OAAO,CAIlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAQlB;IAED;;;;OAIG;IACH,mBAHW,QAAQ,GACN,OAAO,CAKnB;IAED,sBAaC;IAGD;;;;OAIG;IACH,mBAHW,MAAM,UACN,UAAU,QAOpB;IAED;;;;OAIG;IACH,uBAHW,UAAU,GACT,OAAO,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,EAAE,iBACd,MAAM,GACJ,MAAM,CA8BlB;IA4DL;;;OAGG;IACH,qBAFU,OAAO,CAEgB;CANhC;2BA/U0B,iBAAiB;yBADnB,eAAe;qBANnB,WAAW"}
+{"version":3,"file":"TopoTriangle.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoTriangle.js"],"names":[],"mappings":"AAWA;IAmRI;;;;;;;;;;;;OAYG;IACH,sBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,CA4CvB;IAzUD;;;OAGG;IACH,OAFU,MAAM,CAEQ;IACxB;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IACd;;;OAGG;IACH,OAFU,QAAQ,EAAE,CAET;IAEX;;;OAGG;IACH,QAFU,MAAM,EAAE,OAAK,CAEJ;IAEnB,uBAEC;IAED;;;OAGG;IACH,YAFW,YAAY,QAQtB;IAED,sBAMC;IAED;;;;OAIG;IACH,+BAFY,OAAO,CA0ClB;IAED;;;OAGG;IACH,YAFY,OAAO,CAKlB;IAED;;;;OAIG;IACH,sBAHW,QAAQ,eACR,QAAQ,QAIlB;IAED;;;;OAIG;IACH,wBAHW,UAAU,eACV,UAAU,QAMpB;IAED;;OAEG;IACH,gCASC;IAED;;OAEG;IACH,eAmBC;IAED;;;OAGG;IACH,WAFW,QAAQ,QAMlB;IAED;;;;OAIG;IACH,iBAHW,QAAQ,GACP,OAAO,CAIlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAQlB;IAED;;;;OAIG;IACH,mBAHW,QAAQ,GACN,OAAO,CAKnB;IAED,sBAaC;IAGD;;;;OAIG;IACH,mBAHW,MAAM,UACN,UAAU,QAOpB;IAED;;;;OAIG;IACH,uBAHW,UAAU,GACT,OAAO,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,EAAE,iBACd,MAAM,GACJ,MAAM,CA8BlB;IA4DL;;;OAGG;IACH,qBAFU,OAAO,CAEgB;CANhC;2BA/U0B,iBAAiB;yBADnB,eAAe"}

package/src/core/geom/3d/topology/struct/TopoTriangle.js

@@ -1,4 +1,4 @@
-import { vec3 } from "gl-matrix";
+import { v3_copy_array } from "../../../vec3/v3_copy_array.js";
 import { assert } from "../../../../assert.js";
 import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
@@ -45,7 +45,7 @@ export class TopoTriangle {
         this.vertices = other.vertices.slice();
         this.edges = other.edges.slice();
 
-        vec3.copy(this.normal, other.normal);
+        v3_copy_array(this.normal, 0, other.normal, 0);
     }
 
     clone() {

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_face_find_path_polyanya.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js"],"names":[],"mappings":"AA2TA;;;;;;;;;;;;;;GAcG;AACH,wDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CA+HlB"}
+{"version":3,"file":"bt_mesh_face_find_path_polyanya.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js"],"names":[],"mappings":"AAwSA;;;;;;;;;;;;;;GAcG;AACH,wDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CA+HlB"}