@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -267,7 +267,10 @@ export class UnionShape3D extends AbstractShape3D {
         return false;
     }
 
-    sample_random_point_in_volume(result, result_offset, random) {
+    sample_random_point_in_volume(result, result_offset, random) {
+        if (this.__volume_sum === -1) {
+            this.__compute_volume_variables();
+        }
         const children = this.children;
         const child_count = children.length;
 
@@ -284,7 +287,10 @@ export class UnionShape3D extends AbstractShape3D {
         for (i = 0; i < SAMPLE_REJECTION_ATTEMPT_MAX; i++) {
 
             // sample shape
-            child.sample_random_point_in_volume(result, result_offset, random);
+            child.sample_random_point_in_volume(result, result_offset, random);
+            scratch_direction[0] = result[result_offset];
+            scratch_direction[1] = result[result_offset + 1];
+            scratch_direction[2] = result[result_offset + 2];
 
             /*
             because underlying shapes can overlap and we wish to offer a union, just returning the sample would result in over-sampling in areas where shapes overlap
@@ -300,7 +306,7 @@ export class UnionShape3D extends AbstractShape3D {
                     continue;
                 }
 
-                if (child_1.contains_point(result)) {
+                if (child_1.contains_point(scratch_direction)) {
                     collision_count++;
                 }
             }

package/src/core/geom/3d/shape/json/shape_to_type.js

@@ -4,7 +4,7 @@ import { PlaneShape3D } from "../PlaneShape3D.js";
 import { SphereShape3D } from "../SphereShape3D.js";
 import { TransformedShape3D } from "../TransformedShape3D.js";
 import { UnionShape3D } from "../UnionShape3D.js";
-import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { BoxShape3D } from "../BoxShape3D.js";
 
 /**
  *
@@ -14,7 +14,7 @@ import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
 export function shape_to_type(shape) {
     if (shape instanceof UnionShape3D) {
         return 'union';
-    } else if (shape instanceof UnitCubeShape3D) {
+    } else if (shape instanceof BoxShape3D) {
         return 'cube';
     } else if (shape instanceof SphereShape3D) {
         // Covers UnitSphereShape3D (radius 1) and SphereShape3D (arbitrary);

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

@@ -1,17 +1,17 @@
-/**
- * @readonly
- * @type {Float32Array}
- */
-export const SH3_COEFFICIENTS = new Float32Array([
-    0.28209479177387814,    // 0: 0  0
-
-    -0.4886025119029199,    // 1: 1 -1
-    0.4886025119029199,     // 2: 1  0
-    -0.4886025119029199,    // 3: 1  1
-
-    1.0925484305920792,     // 4: 2 -2
-    -1.0925484305920792,    // 5: 2 -1
-    0.31539156525252005,    // 6: 2  0
-    -1.0925484305920792,    // 7: 2  1
-    0.5462742152960396      // 8: 2  2
-]);
+/**
+ * @readonly
+ * @type {Float32Array}
+ */
+export const SH3_COEFFICIENTS = new Float32Array([
+    0.28209479177387814,    // 0: 0  0
+
+    0.4886025119029199,     // 1: 1 -1
+    0.4886025119029199,     // 2: 1  0
+    0.4886025119029199,     // 3: 1  1
+
+    1.0925484305920792,     // 4: 2 -2
+    1.0925484305920792,     // 5: 2 -1
+    0.31539156525252005,    // 6: 2  0
+    1.0925484305920792,     // 7: 2  1
+    0.5462742152960396      // 8: 2  2
+]);

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsBI;;;OAGG;IACH,2BAFW,MAAM,EAgChB;IAvDD;;;;OAIG;IACH,mBAAe;IAEf;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IASf;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAIlC;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,QAAM,uBAavD;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA7xB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsBI;;;OAGG;IACH,2BAFW,MAAM,EAgChB;IAvDD;;;;OAIG;IACH,mBAAe;IAEf;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IASf;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAIlC;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,QAAM,uBAavD;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CAgCjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BAjyB4B,iCAAiC"}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -196,7 +196,7 @@ export class TetrahedralMesh {
     clear() {
 
         // clear data
-        this.__data_uint32.fill(0, 0, this.__used_end);
+        this.__data_uint32.fill(0, 0, this.__used_end * LAYOUT_TETRA_WORD_COUNT);
 
         // reset metadata
         this.__used_end = 0;
@@ -430,7 +430,11 @@ export class TetrahedralMesh {
     allocate() {
         if (this.__free_pointer > 0) {
             this.__free_pointer--;
-            return this.__free[this.__free_pointer];
+            const tetra_index = this.__free[this.__free_pointer];
+            for (let i = 0; i < 4; i++) {
+                this.setNeighbour(tetra_index, i, INVALID_NEIGHBOUR);
+            }
+            return tetra_index;
         }
 
         const tetra_index = this.__used_end;

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_carve_outside_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js"],"names":[],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY,4BAE5B;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsD3C"}
+{"version":3,"file":"tetrahedral_mesh_carve_outside_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js"],"names":[],"mappings":"AAoGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY,4BAE5B;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsD3C"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js

@@ -1,4 +1,5 @@
-import { bt_mesh_build_surface_triangle_bvh, SURFACE_PARITY_RAY_COUNT, SURFACE_PARITY_RAY_DIRECTIONS } from "../topology/struct/binary/query/bt_mesh_surface_ray_parity.js";
+import { bt_mesh_build_face_bvh } from "../topology/struct/binary/query/bt_mesh_build_face_bvh.js";
+import { SURFACE_PARITY_RAY_COUNT, SURFACE_PARITY_RAY_DIRECTIONS } from "../topology/struct/binary/query/bt_mesh_surface_ray_parity.js";
 import { assert } from "../../../assert.js";
 import { BVH, NULL_NODE } from "../../../bvh2/bvh3/BVH.js";
 import { bvh_query_user_data_ray } from "../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
@@ -125,7 +126,7 @@ export function tetrahedral_mesh_carve_outside_surface(tet_mesh, positions, surf
     assert.equal(surface.isBinaryTopology, true, 'surface.isBinaryTopology !== true');
 
     const surface_bvh = new BVH();
-    bt_mesh_build_surface_triangle_bvh(surface_bvh, surface);
+    bt_mesh_build_face_bvh(surface_bvh, surface);
 
     const live_tets = tet_mesh.getLive();
     const live_count = live_tets.length;

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Containment test, whether tetrahedron defined by vertex indices A,B,C,D contains point (ex, ey, ez) or not.
+ * Implemented using planar tests on each side of the tetrahedron.
+ *
+ * Winding-agnostic: the point is interior when it lies on the same side of all four faces,
+ * whatever sign that side carries. A zero counts as inside under either sign, so a point on a face is contained.
+ *
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} ex
+ * @param {number} ey
+ * @param {number} ez
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point_coords(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, d: number, ex: number, ey: number, ez: number): boolean;
 /**
  * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
  * Implemented using planar tests on each of side of the tetrahedron
@@ -6,7 +24,7 @@
  *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
  *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
  *
- * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} points
  * @param {number} a
  * @param {number} b
  * @param {number} c
@@ -14,5 +32,5 @@
  * @param {number} e
  * @returns {boolean}
  */
-export function tetrahedron_contains_point(points: number[], a: number, b: number, c: number, d: number, e: number): boolean;
+export function tetrahedron_contains_point(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, d: number, e: number): boolean;
 //# sourceMappingURL=tetrahedron_contains_point.d.ts.map

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAoBnB"}
+{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,0DAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAMnB"}

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js

@@ -1,37 +1,52 @@
-import { orient3d_fast } from "../plane/orient3d_fast.js";
-
-/**
- * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
- * Implemented using planar tests on each of side of the tetrahedron
- *
- * NOTE:    similar to https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
- *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
- *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
- *
- * @param {number[]} points
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @param {number} e
- * @returns {boolean}
- */
-export function tetrahedron_contains_point(points, a, b, c, d, e) {
-    const v_a = orient3d_fast(points, b, d, c, e);
-    const v_b = orient3d_fast(points, c, d, a, e);
-    const v_c = orient3d_fast(points, d, b, a, e);
-    const v_d = orient3d_fast(points, a, b, c, e);
-
-    // Winding-agnostic: the point is interior when it lies on the same side of all four faces,
-    // whatever sign that side carries. Rejecting on `> 0` alone assumed a clockwise tet, which is
-    // the opposite of what every tet producer in this package emits and of the convention
-    // `TetrahedralMesh.walkToTetraContainingPoint` steps by - so for a positively-wound tet the
-    // answer was inverted. `MeshShape3D` already carries a private copy of this test for exactly
-    // that reason.
-    //
-    // A zero counts as inside under either sign, so a point on a face is contained.
-    const all_non_negative = v_a >= 0 && v_b >= 0 && v_c >= 0 && v_d >= 0;
-    const all_non_positive = v_a <= 0 && v_b <= 0 && v_c <= 0 && v_d <= 0;
-
-    return all_non_negative || all_non_positive;
-}
+import { orient3d_fast_point } from "../plane/orient3d_fast_point.js";
+
+/**
+ * Containment test, whether tetrahedron defined by vertex indices A,B,C,D contains point (ex, ey, ez) or not.
+ * Implemented using planar tests on each side of the tetrahedron.
+ *
+ * Winding-agnostic: the point is interior when it lies on the same side of all four faces,
+ * whatever sign that side carries. A zero counts as inside under either sign, so a point on a face is contained.
+ *
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} ex
+ * @param {number} ey
+ * @param {number} ez
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point_coords(points, a, b, c, d, ex, ey, ez) {
+    const v_a = orient3d_fast_point(points, b, d, c, ex, ey, ez);
+    const v_b = orient3d_fast_point(points, c, d, a, ex, ey, ez);
+    const v_c = orient3d_fast_point(points, d, b, a, ex, ey, ez);
+    const v_d = orient3d_fast_point(points, a, b, c, ex, ey, ez);
+
+    const all_non_negative = v_a >= 0 && v_b >= 0 && v_c >= 0 && v_d >= 0;
+    const all_non_positive = v_a <= 0 && v_b <= 0 && v_c <= 0 && v_d <= 0;
+
+    return all_non_negative || all_non_positive;
+}
+
+/**
+ * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
+ * Implemented using planar tests on each of side of the tetrahedron
+ *
+ * NOTE:    similar to https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+ *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
+ *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
+ *
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} e
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point(points, a, b, c, d, e) {
+    const e3 = e * 3;
+
+    return tetrahedron_contains_point_coords(points, a, b, c, d, points[e3], points[e3 + 1], points[e3 + 2]);
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_face_normals.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,yEAwCC"}
+{"version":3,"file":"bt_mesh_compute_face_normals.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,yEA0BC"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.js

@@ -1,56 +1,40 @@
-import { assert } from "../../../../../../assert.js";
-import { tri3_compute_normal } from "../../../../triangle/tri3_compute_normal.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
-
-const scratch_normal = new Float32Array(3);
-const scratch_coord_a = new Float32Array(3);
-const scratch_coord_b = new Float32Array(3);
-const scratch_coord_c = new Float32Array(3);
-
-/**
- * Compute face normals for all allocated triangular faces, overwriting any previous value.
- * Non-triangular faces are left untouched.
- *
- * @param {BinaryTopology} mesh
- */
-export function bt_mesh_compute_face_normals(mesh) {
-    assert.defined(mesh, "mesh");
-    assert.notNull(mesh, "mesh");
-    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
-
-    const face_pool = mesh.faces;
-    const face_count = face_pool.size;
-
-    for (let face_id = 0; face_id < face_count; face_id++) {
-        if (!face_pool.is_allocated(face_id)) {
-            continue;
-        }
-
-        const loop_a = mesh.face_read_loop(face_id);
-
-        if (loop_a === NULL_POINTER) {
-            continue;
-        }
-
-        const loop_b = mesh.loop_read_next(loop_a);
-        const loop_c = mesh.loop_read_next(loop_b);
-
-        // must be a triangle
-        if (mesh.loop_read_next(loop_c) !== loop_a) {
-            continue;
-        }
-
-        mesh.vertex_read_coordinate(scratch_coord_a, 0, mesh.loop_read_vertex(loop_a));
-        mesh.vertex_read_coordinate(scratch_coord_b, 0, mesh.loop_read_vertex(loop_b));
-        mesh.vertex_read_coordinate(scratch_coord_c, 0, mesh.loop_read_vertex(loop_c));
-
-        tri3_compute_normal(
-            scratch_normal, 0,
-            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2],
-            scratch_coord_b[0], scratch_coord_b[1], scratch_coord_b[2],
-            scratch_coord_c[0], scratch_coord_c[1], scratch_coord_c[2]
-        );
-
-        mesh.face_write_normal(face_id, scratch_normal, 0);
-    }
-}
+import { assert } from "../../../../../../assert.js";
+import { tri3_compute_normal } from "../../../../triangle/tri3_compute_normal.js";
+import { bt_face_read_triangle_coordinates } from "../query/bt_face_read_triangle.js";
+
+const scratch_normal = new Float32Array(3);
+const scratch_coords = new Float32Array(9);
+
+/**
+ * Compute face normals for all allocated triangular faces, overwriting any previous value.
+ * Non-triangular faces are left untouched.
+ *
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_compute_face_normals(mesh) {
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+
+    const face_pool = mesh.faces;
+    const face_count = face_pool.size;
+
+    for (let face_id = 0; face_id < face_count; face_id++) {
+        if (!face_pool.is_allocated(face_id)) {
+            continue;
+        }
+
+        if (!bt_face_read_triangle_coordinates(scratch_coords, 0, mesh, face_id)) {
+            continue;
+        }
+
+        tri3_compute_normal(
+            scratch_normal, 0,
+            scratch_coords[0], scratch_coords[1], scratch_coords[2],
+            scratch_coords[3], scratch_coords[4], scratch_coords[5],
+            scratch_coords[6], scratch_coords[7], scratch_coords[8]
+        );
+
+        mesh.face_write_normal(face_id, scratch_normal, 0);
+    }
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAHa,QAAQ,EAAE,CAgHtB;yBA1KwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAHa,QAAQ,EAAE,CAsGtB;yBAjKwB,iCAAiC"}