@woosh/meep-engine 3.38.0 → 3.40.0

package/src/core/geom/3d/shape/sdf/sdf3_cylinder.d.ts

@@ -57,4 +57,18 @@ export function sdf3_cylinder(x: number, y: number, z: number, radius: number, h
  * @returns {number} the signed distance
  */
 export function sdf3_cylinder_gradient(out: Float32Array | Float64Array | number[], out_offset: number, x: number, y: number, z: number, radius: number, height: number): number;
+/**
+ * {@link sdf3_cylinder_gradient} with the point and the cylinder read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} cylinder `[radius, height]`
+ * @param {number} cylinder_offset
+ * @returns {void}
+ */
+export function sdf3_cylinder_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, point: Float32Array | Float64Array | number[], point_offset: number, cylinder: Float32Array | Float64Array | number[], cylinder_offset: number): void;
 //# sourceMappingURL=sdf3_cylinder.d.ts.map

package/src/core/geom/3d/shape/sdf/sdf3_cylinder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdf3_cylinder.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_cylinder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;GASG;AACH,iCAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;GAWG;AACH,4CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAuDlB"}
+{"version":3,"file":"sdf3_cylinder.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_cylinder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;GASG;AACH,iCAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;GAWG;AACH,4CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;;;;;;;;;GAYG;AACH,kDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,YACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,GACJ,IAAI,CA+DhB"}

package/src/core/geom/3d/shape/sdf/sdf3_cylinder.js

@@ -71,6 +71,43 @@ export function sdf3_cylinder(x, y, z, radius, height) {
  * @returns {number} the signed distance
  */
 export function sdf3_cylinder_gradient(out, out_offset, x, y, z, radius, height) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    SCALAR_SHAPE[0] = radius;
+    SCALAR_SHAPE[1] = height;
+
+    sdf3_cylinder_gradient_array(SCALAR_RESULT, 0, SCALAR_POINT, 0, SCALAR_SHAPE, 0);
+
+    out[out_offset] = SCALAR_RESULT[0];
+    out[out_offset + 1] = SCALAR_RESULT[1];
+    out[out_offset + 2] = SCALAR_RESULT[2];
+
+    return SCALAR_RESULT[3];
+}
+
+/**
+ * {@link sdf3_cylinder_gradient} with the point and the cylinder read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} cylinder `[radius, height]`
+ * @param {number} cylinder_offset
+ * @returns {void}
+ */
+export function sdf3_cylinder_gradient_array(out, out_offset, point, point_offset, cylinder, cylinder_offset) {
+    const x = point[point_offset];
+    const y = point[point_offset + 1];
+    const z = point[point_offset + 2];
+
+    const radius = cylinder[cylinder_offset];
+    const height = cylinder[cylinder_offset + 1];
+
     const s = Math.sqrt(x * x + z * z);
 
     const radial = s - radius;
@@ -106,21 +143,43 @@ export function sdf3_cylinder_gradient(out, out_offset, x, y, z, radius, height)
         out[out_offset] = ux * wr;
         out[out_offset + 1] = axis_sign * wa;
         out[out_offset + 2] = uz * wr;
+        out[out_offset + 3] = outside;
 
-        return outside;
+        return;
     }
 
     if (radial >= axial) {
         out[out_offset] = ux;
         out[out_offset + 1] = 0;
         out[out_offset + 2] = uz;
+        out[out_offset + 3] = radial;
 
-        return radial;
+        return;
     }
 
     out[out_offset] = 0;
     out[out_offset + 1] = axis_sign;
     out[out_offset + 2] = 0;
-
-    return axial;
+    out[out_offset + 3] = axial;
 }
+
+/**
+ * The scalar form's point, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * The scalar form's `[radius, height]`.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_SHAPE = new Float64Array(2);
+
+/**
+ * The scalar form's gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);

package/src/core/geom/3d/shape/sdf/sdf3_plane.d.ts

@@ -49,4 +49,19 @@ export function sdf3_plane(x: number, y: number, z: number, normal_x: number, no
  * @returns {number} the signed distance
  */
 export function sdf3_plane_gradient(out: Float32Array | Float64Array | number[], out_offset: number, x: number, y: number, z: number, normal_x: number, normal_y: number, normal_z: number, offset: number): number;
+/**
+ * {@link sdf3_plane_gradient} with the point and the plane read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} plane `[normal_x, normal_y, normal_z, offset]`: the unit
+ *   normal, and how far along it the boundary plane sits from the origin
+ * @param {number} plane_offset index of `normal_x` in `plane`
+ * @returns {void}
+ */
+export function sdf3_plane_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, point: Float32Array | Float64Array | number[], point_offset: number, plane: Float32Array | Float64Array | number[], plane_offset: number): void;
 //# sourceMappingURL=sdf3_plane.d.ts.map

package/src/core/geom/3d/shape/sdf/sdf3_plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdf3_plane.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_plane.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;GAYG;AACH,8BATW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;GAaG;AACH,yCAXW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAQlB"}
+{"version":3,"file":"sdf3_plane.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_plane.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;GAYG;AACH,8BATW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;GAaG;AACH,yCAXW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;;;;GAaG;AACH,+CAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAElC,MAAM,GACJ,IAAI,CAgBhB"}

package/src/core/geom/3d/shape/sdf/sdf3_plane.js

@@ -53,9 +53,71 @@ export function sdf3_plane(x, y, z, normal_x, normal_y, normal_z, offset) {
  * @returns {number} the signed distance
  */
 export function sdf3_plane_gradient(out, out_offset, x, y, z, normal_x, normal_y, normal_z, offset) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    SCALAR_SHAPE[0] = normal_x;
+    SCALAR_SHAPE[1] = normal_y;
+    SCALAR_SHAPE[2] = normal_z;
+    SCALAR_SHAPE[3] = offset;
+
+    sdf3_plane_gradient_array(SCALAR_RESULT, 0, SCALAR_POINT, 0, SCALAR_SHAPE, 0);
+
+    out[out_offset] = SCALAR_RESULT[0];
+    out[out_offset + 1] = SCALAR_RESULT[1];
+    out[out_offset + 2] = SCALAR_RESULT[2];
+
+    return SCALAR_RESULT[3];
+}
+
+/**
+ * {@link sdf3_plane_gradient} with the point and the plane read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} plane `[normal_x, normal_y, normal_z, offset]`: the unit
+ *   normal, and how far along it the boundary plane sits from the origin
+ * @param {number} plane_offset index of `normal_x` in `plane`
+ * @returns {void}
+ */
+export function sdf3_plane_gradient_array(out, out_offset, point, point_offset, plane, plane_offset) {
+    const x = point[point_offset];
+    const y = point[point_offset + 1];
+    const z = point[point_offset + 2];
+
+    const normal_x = plane[plane_offset];
+    const normal_y = plane[plane_offset + 1];
+    const normal_z = plane[plane_offset + 2];
+    const offset = plane[plane_offset + 3];
+
     out[out_offset] = normal_x;
     out[out_offset + 1] = normal_y;
     out[out_offset + 2] = normal_z;
-
-    return x * normal_x + y * normal_y + z * normal_z - offset;
+    out[out_offset + 3] = x * normal_x + y * normal_y + z * normal_z - offset;
 }
+
+/**
+ * The scalar form's point, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * The scalar form's `[normal_x, normal_y, normal_z, offset]`.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_SHAPE = new Float64Array(4);
+
+/**
+ * The scalar form's gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);

package/src/core/geom/3d/shape/sdf/sdf3_sphere.d.ts

@@ -13,6 +13,13 @@
  * than the question. {@link SphereShape3D} calls these too, so there is one
  * implementation of the arithmetic rather than two that can drift.
  *
+ * The gradient has an array form beside the scalar one, `_array`, which reads
+ * the point and the shape from arrays and writes the distance after the
+ * gradient instead of returning it. Cloth calls it from its per-particle loops,
+ * where a number passed to a call V8 does not inline, or returned from one, is
+ * boxed into a heap object. The scalar form packs its arguments and calls the
+ * array form, so the arithmetic is still written once.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -38,4 +45,18 @@ export function sdf3_sphere(x: number, y: number, z: number, radius: number): nu
  * @returns {number} the signed distance
  */
 export function sdf3_sphere_gradient(out: Float32Array | Float64Array | number[], out_offset: number, x: number, y: number, z: number, radius: number): number;
+/**
+ * {@link sdf3_sphere_gradient} with the point and the sphere read from arrays, and the distance
+ * written after the gradient rather than returned.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} sphere `[radius]`
+ * @param {number} sphere_offset
+ * @returns {void}
+ */
+export function sdf3_sphere_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, point: Float32Array | Float64Array | number[], point_offset: number, sphere: Float32Array | Float64Array | number[], sphere_offset: number): void;
 //# sourceMappingURL=sdf3_sphere.d.ts.map

package/src/core/geom/3d/shape/sdf/sdf3_sphere.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdf3_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_sphere.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;GAQG;AACH,+BANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,0CARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAsBlB"}
+{"version":3,"file":"sdf3_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_sphere.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;GAQG;AACH,+BANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,0CARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;GAYG;AACH,gDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,UACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,GACJ,IAAI,CA4BhB"}

package/src/core/geom/3d/shape/sdf/sdf3_sphere.js

@@ -20,6 +20,13 @@ import {
  * than the question. {@link SphereShape3D} calls these too, so there is one
  * implementation of the arithmetic rather than two that can drift.
  *
+ * The gradient has an array form beside the scalar one, `_array`, which reads
+ * the point and the shape from arrays and writes the distance after the
+ * gradient instead of returning it. Cloth calls it from its per-particle loops,
+ * where a number passed to a call V8 does not inline, or returned from one, is
+ * boxed into a heap object. The scalar form packs its arguments and calls the
+ * array form, so the arithmetic is still written once.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -49,6 +56,41 @@ export function sdf3_sphere(x, y, z, radius) {
  * @returns {number} the signed distance
  */
 export function sdf3_sphere_gradient(out, out_offset, x, y, z, radius) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    SCALAR_SHAPE[0] = radius;
+
+    sdf3_sphere_gradient_array(SCALAR_RESULT, 0, SCALAR_POINT, 0, SCALAR_SHAPE, 0);
+
+    out[out_offset] = SCALAR_RESULT[0];
+    out[out_offset + 1] = SCALAR_RESULT[1];
+    out[out_offset + 2] = SCALAR_RESULT[2];
+
+    return SCALAR_RESULT[3];
+}
+
+/**
+ * {@link sdf3_sphere_gradient} with the point and the sphere read from arrays, and the distance
+ * written after the gradient rather than returned.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} sphere `[radius]`
+ * @param {number} sphere_offset
+ * @returns {void}
+ */
+export function sdf3_sphere_gradient_array(out, out_offset, point, point_offset, sphere, sphere_offset) {
+    const x = point[point_offset];
+    const y = point[point_offset + 1];
+    const z = point[point_offset + 2];
+
+    const radius = sphere[sphere_offset];
+
     const length = Math.sqrt(x * x + y * y + z * z);
 
     if (length < SDF3_EPSILON) {
@@ -57,8 +99,9 @@ export function sdf3_sphere_gradient(out, out_offset, x, y, z, radius) {
         out[out_offset] = SDF3_DEGENERATE_NORMAL_X;
         out[out_offset + 1] = SDF3_DEGENERATE_NORMAL_Y;
         out[out_offset + 2] = SDF3_DEGENERATE_NORMAL_Z;
+        out[out_offset + 3] = -radius;
 
-        return -radius;
+        return;
     }
 
     const inverse = 1 / length;
@@ -66,6 +109,26 @@ export function sdf3_sphere_gradient(out, out_offset, x, y, z, radius) {
     out[out_offset] = x * inverse;
     out[out_offset + 1] = y * inverse;
     out[out_offset + 2] = z * inverse;
-
-    return length - radius;
+    out[out_offset + 3] = length - radius;
 }
+
+/**
+ * The scalar form's point, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * The scalar form's `[radius]`.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_SHAPE = new Float64Array(1);
+
+/**
+ * The scalar form's gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);

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

@@ -17,6 +17,8 @@
  *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
  *     queries that correctly handle disconnected meshes (which the
  *     previous tet-walker did not).
+ *  6. The surface triangles' edge and corner classes
+ *     ({@link MeshShape3D#get_triangle_edge_flags}) are cooked.
  *
  * The caller's buffers are NOT cloned — they're attached to the shape
  * directly. Don't mutate them after handing them in.

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

@@ -1 +1 @@
-{"version":3,"file":"shape3_mesh_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/shape3_mesh_from_geometry.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qDAJW,YAAY,WACZ,WAAW,GACT,WAAW,CAgCvB;4BA3D2B,kBAAkB"}
+{"version":3,"file":"shape3_mesh_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/shape3_mesh_from_geometry.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qDAJW,YAAY,WACZ,WAAW,GACT,WAAW,CAqCvB;4BAlE2B,kBAAkB"}

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

@@ -23,6 +23,8 @@ import { MeshShape3D } from "./MeshShape3D.js";
  *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
  *     queries that correctly handle disconnected meshes (which the
  *     previous tet-walker did not).
+ *  6. The surface triangles' edge and corner classes
+ *     ({@link MeshShape3D#get_triangle_edge_flags}) are cooked.
  *
  * The caller's buffers are NOT cloned — they're attached to the shape
  * directly. Don't mutate them after handing them in.
@@ -60,5 +62,10 @@ export function shape3_mesh_from_geometry(positions, indices) {
     // 5. Refresh cached bbox / volume / surface area.
     shape.recompute_cached();
 
+    // 6. Cook the triangles' edge and corner classes now rather than at the first contact on the
+    //    mesh, where they would be a hitch inside a physics step: a 180k-triangle grid takes 0.05 s,
+    //    where steps 1-5 took 311 s (mesh_compute_triangle_edge_flags, "Cost").
+    shape.get_triangle_edge_flags();
+
     return shape;
 }

package/src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Per-triangle {@link TriangleEdgeFlags} of an indexed triangle surface: for each of a triangle's
+ * edges, whether the neighbour across it lies in the same plane (FLAT), bends up (CONCAVE), or the
+ * edge is a real one — a ridge, a rim, or an edge more than two triangles share; and for each of its
+ * corners, whether every edge meeting there is flat (FLAT), or a real edge does.
+ *
+ * Neighbours are found by POSITION, not by index: vertices within the weld's tolerance of one another
+ * ({@link weld_tolerance}: 2^-20 of the mesh's scale, never a quarter of its shortest edge) are one
+ * vertex, so a surface whose buffer splits vertices for normals or UVs — every triangle its own three,
+ * as exporters produce — has the adjacency it looks like it has, float rounding and all. An edge is shared when exactly two triangles have it. A
+ * triangle with two corners at one point has no area and no edges: it is left out, and the triangles
+ * around it meet across it.
+ *
+ * An edge no other triangle has may still have neighbours: a T-junction, where one triangle's edge
+ * runs along two or more shorter edges of the triangles on its other side, ending at a vertex in the
+ * middle of it. The shorter edges are found end to end along it (up to {@link T_JUNCTION_MAX_PIECES})
+ * and the edges are classified against one another: the long edge is FLAT when every piece is, so is
+ * each piece against it.
+ *
+ * Box3D cooks the same edge flags into its meshes (mesh.c `b3IdentifyEdges`, MIT, Erin Catto), from
+ * which this is ported, adjacency by position and T-junctions aside.
+ *
+ * ## Cost
+ *
+ * Linear in the triangles at any vertex valence — a half-edge's partners are found by binary search
+ * in its vertices' runs, sorted by end vertex — once per surface; the result, 2 bytes a triangle, is
+ * meant to be kept. Measured: a 1M-triangle grid, 0.47 s; 180k triangles, 0.07 s indexed and 0.1 s
+ * with every triangle its own three vertices, against 311 s for {@link shape3_mesh_from_geometry} to
+ * build the shape; a fan of 100k triangles round one vertex, 0.05–0.07 s (scanning each vertex's
+ * half-edges instead took 86 s there). Only the T-junction walk scans a vertex's lone half-edges, so
+ * rim edges by the thousand meeting at one vertex stay quadratic (10k loose triangles sharing one
+ * corner: 0.8 s). Transient arrays: the welded index and its table, 8 to 20 bytes a vertex; the
+ * half-edges sorted twice, 8 bytes a vertex and 24 a triangle — about 40 MB for 1M indexed
+ * triangles. (An edge hash table here cost 168 MB and 0.65 s.)
+ *
+ * @param {ArrayLike<number>} positions flat `(x, y, z)` per vertex
+ * @param {ArrayLike<number>} indices three per triangle, wound CCW seen from outside
+ * @returns {Uint16Array} one entry per triangle
+ */
+export function mesh_compute_triangle_edge_flags(positions: ArrayLike<number>, indices: ArrayLike<number>): Uint16Array;
+//# sourceMappingURL=mesh_compute_triangle_edge_flags.d.ts.map

package/src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_compute_triangle_edge_flags.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.js"],"names":[],"mappings":"AAyNA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,4DAJW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,WAAW,CA2JvB"}