@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -303,6 +303,14 @@ export class UnionShape3D extends AbstractShape3D {
     support(result, result_offset, direction_x, direction_y, direction_z) {
         let best_distance = -Infinity;
 
+        // NOTE: the winner is held in locals, not written into `result` as it is found. When this
+        // union is itself a child of another one, `result` IS `scratch_array` - the outer union
+        // passed its own module scratch in - so copying scratch into result was a no-op, and
+        // whatever the last child happened to write was what the outer read back.
+        let best_x = 0;
+        let best_y = 0;
+        let best_z = 0;
+
         const children = this.children;
         const child_count = children.length;
 
@@ -311,20 +319,29 @@ export class UnionShape3D extends AbstractShape3D {
 
             child.support(scratch_array, 0, direction_x, direction_y, direction_z);
 
+            const x = scratch_array[0];
+            const y = scratch_array[1];
+            const z = scratch_array[2];
+
             const d = v3_dot(
-                scratch_array[0], scratch_array[1], scratch_array[2],
+                x, y, z,
                 direction_x, direction_y, direction_z
             );
 
             if (d > best_distance) {
-                // best candidate so far, write to result
-                array_copy(scratch_array, 0, result, result_offset, 3);
+                // best candidate so far
+                best_x = x;
+                best_y = y;
+                best_z = z;
 
                 best_distance = d;
             }
 
         }
 
+        result[result_offset] = best_x;
+        result[result_offset + 1] = best_y;
+        result[result_offset + 2] = best_z;
     }
 
     /**

package/src/core/geom/3d/shape/json/type_adapters.d.ts

@@ -1,7 +1,16 @@
 export namespace type_adapters {
     namespace cube {
-        function read(): UnitCubeShape3D;
-        function write(): {};
+        function read({ half_extents }?: {
+            half_extents: any;
+        }): UnitCubeShape3D;
+        /**
+         * @param {UnitCubeShape3D} object
+         */
+        function write(object: UnitCubeShape3D): {
+            half_extents?: undefined;
+        } | {
+            half_extents: number[];
+        };
     }
     namespace sphere {
         function read({ radius }?: {

package/src/core/geom/3d/shape/json/type_adapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type_adapters.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/json/type_adapters.js"],"names":[],"mappings":";;QAaQ,iCAEC;QACD,qBAEC;;;QAGD;;0BAQC;QACD;;WAEG;QACH;;;;UAIC;;;QAGD;;;2BAEC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;;4BAEC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;;yBAEC;QACD;;WAEG;QACH;;;UAKC;;;QAGD;;;+BAIC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;yBAIC;QACD;;;WAGG;QACH;;UAIC;;;gCA5GuB,uBAAuB;8BAHzB,qBAAqB;+BAHpB,sBAAsB;gCACrB,uBAAuB;6BAC1B,oBAAoB;mCAEd,0BAA0B;6BAChC,oBAAoB"}
+{"version":3,"file":"type_adapters.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/json/type_adapters.js"],"names":[],"mappings":";;QAiBQ;;4BAQC;QACD;;WAEG;QACH;;;;UAWC;;;QAKD;;0BAMC;QACD;;WAEG;QACH;;;;UAMC;;;QAGD;;;2BAEC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;;4BAEC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;;yBAEC;QACD;;WAEG;QACH;;;UAKC;;;QAGD;;;+BAIC;QACD;;;WAGG;QACH;;;UAKC;;;QAGD;;yBAIC;QACD;;;WAGG;QACH;;UAIC;;;gCApIuB,uBAAuB;8BAHzB,qBAAqB;+BAHpB,sBAAsB;gCACrB,uBAAuB;6BAC1B,oBAAoB;mCAEd,0BAA0B;6BAChC,oBAAoB"}

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

@@ -11,30 +11,54 @@ import { shape_to_json } from "./shape_to_json.js";
 
 export const type_adapters = {
     'cube': {
-        read() {
-            return UnitCubeShape3D.INSTANCE;
+        // NOTE: a fresh instance, never the singleton. Handing the shared INSTANCE to every
+        // deserialised scene aliases them all onto one mutable object - UnitCubeShape3D is a
+        // BoxShape3D now, so `half_extents` is writable and one caller resizing its cube resized
+        // everybody's.
+        read({ half_extents } = {}) {
+            const cube = new UnitCubeShape3D();
+
+            if (half_extents !== undefined) {
+                cube.half_extents.set(half_extents[0], half_extents[1], half_extents[2]);
+            }
+
+            return cube;
         },
-        write() {
-            return {};
+        /**
+         * @param {UnitCubeShape3D} object
+         */
+        write(object) {
+            const h = object.half_extents;
+
+            // Omit the extents for the unit case to keep the serialized form byte-identical to the
+            // pre-BoxShape3D 'cube' tag; carry them otherwise, or a resized cube silently loads
+            // back at (0.5, 0.5, 0.5).
+            if (h.x === 0.5 && h.y === 0.5 && h.z === 0.5) {
+                return {};
+            }
+
+            return { half_extents: [h.x, h.y, h.z] };
         }
     },
     'sphere': {
+        // Backward-compatible: legacy 'sphere' entries have no radius and are unit spheres. A
+        // fresh instance rather than the singleton, for the same reason as 'cube'.
         read({ radius } = {}) {
-            // Backward-compatible: legacy 'sphere' entries have no radius and
-            // map to the unit-sphere singleton. A radius of 1 is also treated
-            // as the unit sphere so re-saved unit spheres keep sharing INSTANCE.
-            if (radius === undefined || radius === 1) {
-                return UnitSphereShape3D.INSTANCE;
+            if (radius === undefined) {
+                return new UnitSphereShape3D();
             }
+
             return SphereShape3D.from(radius);
         },
         /**
          * @param {SphereShape3D} object
          */
         write(object) {
-            // Omit radius for the unit case to keep the serialized form
-            // byte-identical to the pre-SphereShape3D 'sphere' tag.
-            return object.radius === 1 ? {} : { radius: object.radius };
+            // Omit radius only for an actual UnitSphereShape3D, so the serialized form stays
+            // byte-identical to the pre-SphereShape3D 'sphere' tag. Keyed on the class, not on the
+            // value: a SphereShape3D of radius 1 that came back as a UnitSphereShape3D is a
+            // different class, and `equals` starts with a constructor check.
+            return object instanceof UnitSphereShape3D ? {} : { radius: object.radius };
         }
     },
     'capsule': {

package/src/core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.d.ts

@@ -6,6 +6,19 @@
  * c3 = 0.24770795610037568833406429782001;    // Â2.Y20 = 1/16 * sqrt(5.PI)
  * c4 = 0.88622692545275801364908374167057;    // Â0.Y00 = 1/2 * sqrt(PI)
  *
+ * ## Sign convention
+ *
+ * The all-positive real basis, with no Condon-Shortley phase — the same convention as
+ * {@link sh3_basis_at} on the projection side, as `chunk_sh3_basis_at`, `chunk_sh2_cosine_lobe` and
+ * `chunk_sh2_hallucinate_ZH3_irradiance`, and as the GPU twin of this function,
+ * `chunk_sh3_color_get_irradiance_at`.
+ *
+ * The three.js source this was ported from negates the odd-m terms, and so did this — coefficients 1, 3,
+ * 5 and 7 were subtracted. Every coefficient set this engine produces goes through the all-positive
+ * `sh3_basis_at`, so the reconstruction was in the wrong convention for all of them: the L1 band flipped
+ * and the reconstructed peak moved off the source direction. Reading a set projected in the *other*
+ * convention needs the coefficients negated at the call site, not the reconstruction changed here.
+ *
  * @see https://github.com/mrdoob/three.js/blob/d081c5a3501d272d19375fab1b01fedf9df29b22/src/math/SphericalHarmonics3.js#L85
  * @see https://graphics.stanford.edu/papers/envmap/envmap.pdf
  * @see https://www.ppsloan.org/publications/StupidSH36.pdf

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

@@ -1 +1 @@
-{"version":3,"file":"sh3_sample_irradiance_by_direction.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2DARW,MAAM,EAAE,iBACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,mBACN,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAkChB"}
+{"version":3,"file":"sh3_sample_irradiance_by_direction.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,2DARW,MAAM,EAAE,iBACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,mBACN,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAkChB"}

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

@@ -6,6 +6,19 @@
  * c3 = 0.24770795610037568833406429782001;    // Â2.Y20 = 1/16 * sqrt(5.PI)
  * c4 = 0.88622692545275801364908374167057;    // Â0.Y00 = 1/2 * sqrt(PI)
  *
+ * ## Sign convention
+ *
+ * The all-positive real basis, with no Condon-Shortley phase — the same convention as
+ * {@link sh3_basis_at} on the projection side, as `chunk_sh3_basis_at`, `chunk_sh2_cosine_lobe` and
+ * `chunk_sh2_hallucinate_ZH3_irradiance`, and as the GPU twin of this function,
+ * `chunk_sh3_color_get_irradiance_at`.
+ *
+ * The three.js source this was ported from negates the odd-m terms, and so did this — coefficients 1, 3,
+ * 5 and 7 were subtracted. Every coefficient set this engine produces goes through the all-positive
+ * `sh3_basis_at`, so the reconstruction was in the wrong convention for all of them: the L1 band flipped
+ * and the reconstructed peak moved off the source direction. Reading a set projected in the *other*
+ * convention needs the coefficients negated at the call site, not the reconstruction changed here.
+ *
  * @see https://github.com/mrdoob/three.js/blob/d081c5a3501d272d19375fab1b01fedf9df29b22/src/math/SphericalHarmonics3.js#L85
  * @see https://graphics.stanford.edu/papers/envmap/envmap.pdf
  * @see https://www.ppsloan.org/publications/StupidSH36.pdf
@@ -36,15 +49,15 @@ export function sh3_sample_irradiance_by_direction(
         channel_value = harmonics[harmonics_offset + i] * 0.88622692545275801364908374167057;
 
         // band 1
-        channel_value -= harmonics[harmonics_offset + dimension_count + i] * 2.0 * 0.51166335397324424423977581244463 * y;
+        channel_value += harmonics[harmonics_offset + dimension_count + i] * 2.0 * 0.51166335397324424423977581244463 * y;
         channel_value += harmonics[harmonics_offset + dimension_count * 2 + i] * 2.0 * 0.51166335397324424423977581244463 * z;
-        channel_value -= harmonics[harmonics_offset + dimension_count * 3 + i] * 2.0 * 0.51166335397324424423977581244463 * x;
+        channel_value += harmonics[harmonics_offset + dimension_count * 3 + i] * 2.0 * 0.51166335397324424423977581244463 * x;
 
         // band 2
         channel_value += harmonics[harmonics_offset + dimension_count * 4 + i] * 2.0 * 0.42904276540489171563379376569857 * x * y;
-        channel_value -= harmonics[harmonics_offset + dimension_count * 5 + i] * 2.0 * 0.42904276540489171563379376569857 * y * z;
+        channel_value += harmonics[harmonics_offset + dimension_count * 5 + i] * 2.0 * 0.42904276540489171563379376569857 * y * z;
         channel_value += harmonics[harmonics_offset + dimension_count * 6 + i] * (3 * z * z - 1) * 0.24770795610037568833406429782001;
-        channel_value -= harmonics[harmonics_offset + dimension_count * 7 + i] * 2.0 * 0.42904276540489171563379376569857 * x * z;
+        channel_value += harmonics[harmonics_offset + dimension_count * 7 + i] * 2.0 * 0.42904276540489171563379376569857 * x * z;
         channel_value += harmonics[harmonics_offset + dimension_count * 8 + i] * 0.42904276540489171563379376569857 * (x * x - y * y);
 
         // write out

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

@@ -0,0 +1,88 @@
+/**
+ * The vertex orderings the tetrahedral flips produce, and the face table they are derived from.
+ *
+ * These exist as data because two different pieces of code need them: the flip modules, which *apply*
+ * them, and `tetrahedral_mesh_improve_quality`, which *scores* a candidate flip without performing it.
+ * The scorer used to re-transcribe both flips' output orderings by hand from the `setVertexIndex` calls,
+ * so changing a canonical ordering — to fix an orientation, to reuse a different slot — left the driver
+ * scoring the old layout and committing flips it believed improved quality and did not. A wrong-mesh
+ * outcome from an edit that looks local and passes the flip modules' own specs.
+ *
+ * `tetrahedral_flip_layouts.spec` performs each flip and checks the result against these tables, so the
+ * two cannot part company again.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Face-vertex layout for a positively-oriented tet: for vertex slot i, the face opposite has these slot
+ * indices in counter-clockwise-from-outside order.
+ *
+ * Derived from the volume formula `vol = (1/6)·det[v0-v3, v1-v3, v2-v3]`:
+ *   - Face opposite v3 is the canonical case (v0, v1, v2).
+ *   - Other faces follow by even-permutation parity to keep the implied tet (face, opposite_vertex)
+ *     positively wound.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FACE_VERTICES_BY_OPPOSITE: number[][];
+/**
+ * Operand order the 2-3 flip's layouts index into: `[p, q, r, d, e]`.
+ *
+ * `p`, `q`, `r` are the shared face's vertices in counter-clockwise-from-outside-t1 order; `d` and `e`
+ * are the two apex vertices, the one opposite the shared face in each input tet.
+ */
+export type TET_FLIP_23_OPERAND = number;
+export namespace TET_FLIP_23_OPERAND {
+    let p: number;
+    let q: number;
+    let r: number;
+    let d: number;
+    let e: number;
+}
+/**
+ * The three tets a 2-3 flip produces, as slot -> operand index into `[p, q, r, d, e]`.
+ *
+ *   T_alpha = (r, q, d, e)
+ *   T_beta  = (p, r, d, e)
+ *   T_gamma = (q, p, d, e)
+ *
+ * Each ordering was derived and verified to keep the new tet's signed volume the same sign as the
+ * original t1/t2 under the engine's convention. The internal neighbour links in
+ * `tetrahedral_mesh_flip_23` are worked out *from* these orderings, so changing one here means
+ * re-deriving those.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FLIP_23_LAYOUTS: number[][];
+/**
+ * Operand order the 3-2 flip's layouts index into: `[v_X, v_Y, v_missing, v_a, v_b]`.
+ *
+ * `v_a` and `v_b` are the ends of the edge being removed; `v_X`, `v_Y` and `v_missing` are the three
+ * ring vertices of the bipyramid's equator.
+ */
+export type TET_FLIP_32_OPERAND = number;
+export namespace TET_FLIP_32_OPERAND {
+    let v_X: number;
+    let v_Y: number;
+    let v_missing: number;
+    let v_a: number;
+    let v_b: number;
+}
+/**
+ * The two tets a 3-2 flip produces, as slot -> operand index into `[v_X, v_Y, v_missing, v_a, v_b]`.
+ *
+ *   new_tet_a = (v_X, v_missing, v_Y, v_a)  → face opposite v_a is (v_X, v_missing, v_Y),
+ *                                             CCW from outside, i.e. CCW from v_b's view
+ *   new_tet_b = (v_X, v_Y, v_missing, v_b)  → face opposite v_b is (v_X, v_Y, v_missing),
+ *                                             CCW from outside, i.e. CCW from v_a's view
+ *
+ * As above, `tetrahedral_mesh_flip_32`'s neighbour links are derived from these.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FLIP_32_LAYOUTS: number[][];
+//# sourceMappingURL=tetrahedral_flip_layouts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_flip_layouts.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_flip_layouts.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;GAWG;AACH,4CAFU,MAAM,EAAE,EAAE,CAOlB;;;;;;;kCASQ,MAAM;;;;;;;;AAUhB;;;;;;;;;;;;;;GAcG;AACH,kCAFU,MAAM,EAAE,EAAE,CAMlB;;;;;;;kCASQ,MAAM;;;;;;;;AAUhB;;;;;;;;;;;;GAYG;AACH,kCAFU,MAAM,EAAE,EAAE,CAKlB"}

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

@@ -0,0 +1,108 @@
+/**
+ * The vertex orderings the tetrahedral flips produce, and the face table they are derived from.
+ *
+ * These exist as data because two different pieces of code need them: the flip modules, which *apply*
+ * them, and `tetrahedral_mesh_improve_quality`, which *scores* a candidate flip without performing it.
+ * The scorer used to re-transcribe both flips' output orderings by hand from the `setVertexIndex` calls,
+ * so changing a canonical ordering — to fix an orientation, to reuse a different slot — left the driver
+ * scoring the old layout and committing flips it believed improved quality and did not. A wrong-mesh
+ * outcome from an edit that looks local and passes the flip modules' own specs.
+ *
+ * `tetrahedral_flip_layouts.spec` performs each flip and checks the result against these tables, so the
+ * two cannot part company again.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Face-vertex layout for a positively-oriented tet: for vertex slot i, the face opposite has these slot
+ * indices in counter-clockwise-from-outside order.
+ *
+ * Derived from the volume formula `vol = (1/6)·det[v0-v3, v1-v3, v2-v3]`:
+ *   - Face opposite v3 is the canonical case (v0, v1, v2).
+ *   - Other faces follow by even-permutation parity to keep the implied tet (face, opposite_vertex)
+ *     positively wound.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FACE_VERTICES_BY_OPPOSITE = [
+    [1, 3, 2], // opposite v0
+    [0, 2, 3], // opposite v1
+    [0, 3, 1], // opposite v2
+    [0, 1, 2], // opposite v3
+];
+
+/**
+ * Operand order the 2-3 flip's layouts index into: `[p, q, r, d, e]`.
+ *
+ * `p`, `q`, `r` are the shared face's vertices in counter-clockwise-from-outside-t1 order; `d` and `e`
+ * are the two apex vertices, the one opposite the shared face in each input tet.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TET_FLIP_23_OPERAND = {
+    p: 0,
+    q: 1,
+    r: 2,
+    d: 3,
+    e: 4
+};
+
+/**
+ * The three tets a 2-3 flip produces, as slot -> operand index into `[p, q, r, d, e]`.
+ *
+ *   T_alpha = (r, q, d, e)
+ *   T_beta  = (p, r, d, e)
+ *   T_gamma = (q, p, d, e)
+ *
+ * Each ordering was derived and verified to keep the new tet's signed volume the same sign as the
+ * original t1/t2 under the engine's convention. The internal neighbour links in
+ * `tetrahedral_mesh_flip_23` are worked out *from* these orderings, so changing one here means
+ * re-deriving those.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FLIP_23_LAYOUTS = [
+    [2, 1, 3, 4], // T_alpha = (r, q, d, e)
+    [0, 2, 3, 4], // T_beta  = (p, r, d, e)
+    [1, 0, 3, 4], // T_gamma = (q, p, d, e)
+];
+
+/**
+ * Operand order the 3-2 flip's layouts index into: `[v_X, v_Y, v_missing, v_a, v_b]`.
+ *
+ * `v_a` and `v_b` are the ends of the edge being removed; `v_X`, `v_Y` and `v_missing` are the three
+ * ring vertices of the bipyramid's equator.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TET_FLIP_32_OPERAND = {
+    v_X: 0,
+    v_Y: 1,
+    v_missing: 2,
+    v_a: 3,
+    v_b: 4
+};
+
+/**
+ * The two tets a 3-2 flip produces, as slot -> operand index into `[v_X, v_Y, v_missing, v_a, v_b]`.
+ *
+ *   new_tet_a = (v_X, v_missing, v_Y, v_a)  → face opposite v_a is (v_X, v_missing, v_Y),
+ *                                             CCW from outside, i.e. CCW from v_b's view
+ *   new_tet_b = (v_X, v_Y, v_missing, v_b)  → face opposite v_b is (v_X, v_Y, v_missing),
+ *                                             CCW from outside, i.e. CCW from v_a's view
+ *
+ * As above, `tetrahedral_mesh_flip_32`'s neighbour links are derived from these.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const TET_FLIP_32_LAYOUTS = [
+    [0, 2, 1, 3], // new_tet_a = (v_X, v_missing, v_Y, v_a)
+    [0, 1, 2, 4], // new_tet_b = (v_X, v_Y, v_missing, v_b)
+];

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_flip_23.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_flip_23.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oEANW,MAAM,MACN,MAAM,OACN,WAAW,GAAC,MAAM,EAAE,QAmK9B"}
+{"version":3,"file":"tetrahedral_mesh_flip_23.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_flip_23.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oEANW,MAAM,MACN,MAAM,OACN,WAAW,GAAC,MAAM,EAAE,QAkK9B"}

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

@@ -1,24 +1,7 @@
 import { assert } from "../../../assert.js";
+import { TET_FACE_VERTICES_BY_OPPOSITE, TET_FLIP_23_LAYOUTS } from "./tetrahedral_flip_layouts.js";
 import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
 
-/**
- * For a tet stored as (v0, v1, v2, v3), the vertices of the face opposite
- * vertex i, in counter-clockwise order viewed from outside the tet (i.e. the
- * standard outward-facing winding for a positively-oriented tet whose signed
- * volume is positive under the engine's `compute_tetrahedron_volume`).
- *
- * Derived from the volume formula vol = (1/6)·det[v0-v3, v1-v3, v2-v3]:
- *   - Face opposite v3 is the canonical case (v0, v1, v2).
- *   - Other faces follow by even-permutation parity to keep the implied tet
- *     (face, opposite_vertex) positively wound.
- */
-const FACE_VERTICES_BY_OPPOSITE = [
-    [1, 3, 2], // opposite v0
-    [0, 2, 3], // opposite v1
-    [0, 3, 1], // opposite v2
-    [0, 1, 2], // opposite v3
-];
-
 /**
  * Perform a 2-3 flip on two tetrahedra that share a face.
  *
@@ -89,7 +72,7 @@ export function tetrahedral_mesh_flip_23(mesh, t1, t2, out) {
     const d = mesh.getVertexIndex(t1, shared_i1);
     const e = mesh.getVertexIndex(t2, shared_i2);
 
-    const face_t1 = FACE_VERTICES_BY_OPPOSITE[shared_i1];
+    const face_t1 = TET_FACE_VERTICES_BY_OPPOSITE[shared_i1];
     const pos_p_in_t1 = face_t1[0];
     const pos_q_in_t1 = face_t1[1];
     const pos_r_in_t1 = face_t1[2];
@@ -141,20 +124,19 @@ export function tetrahedral_mesh_flip_23(mesh, t1, t2, out) {
     // volume the same sign as the original t1/t2 under the engine's
     // convention.
     // -----------------------------------------------------------------
-    mesh.setVertexIndex(T_alpha, 0, r);
-    mesh.setVertexIndex(T_alpha, 1, q);
-    mesh.setVertexIndex(T_alpha, 2, d);
-    mesh.setVertexIndex(T_alpha, 3, e);
+    // T_alpha = (r, q, d, e); T_beta = (p, r, d, e); T_gamma = (q, p, d, e) — written once, in
+    // TET_FLIP_23_LAYOUTS, because tetrahedral_mesh_improve_quality scores a candidate flip against the
+    // same orderings without performing it. The neighbour links below are derived from them.
+    const operands = [p, q, r, d, e];
+    const new_tets = [T_alpha, T_beta, T_gamma];
 
-    mesh.setVertexIndex(T_beta, 0, p);
-    mesh.setVertexIndex(T_beta, 1, r);
-    mesh.setVertexIndex(T_beta, 2, d);
-    mesh.setVertexIndex(T_beta, 3, e);
+    for (let i = 0; i < 3; i++) {
+        const layout = TET_FLIP_23_LAYOUTS[i];
 
-    mesh.setVertexIndex(T_gamma, 0, q);
-    mesh.setVertexIndex(T_gamma, 1, p);
-    mesh.setVertexIndex(T_gamma, 2, d);
-    mesh.setVertexIndex(T_gamma, 3, e);
+        for (let slot = 0; slot < 4; slot++) {
+            mesh.setVertexIndex(new_tets[i], slot, operands[layout[slot]]);
+        }
+    }
 
     // -----------------------------------------------------------------
     // Step 6: internal neighbour links between the three new tets.

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_flip_32.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_flip_32.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,oEAPW,MAAM,MACN,MAAM,MACN,MAAM,OACN,WAAW,GAAC,MAAM,EAAE,QAqM9B"}
+{"version":3,"file":"tetrahedral_mesh_flip_32.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_flip_32.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,oEAPW,MAAM,MACN,MAAM,MACN,MAAM,OACN,WAAW,GAAC,MAAM,EAAE,QAyM9B"}

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

@@ -1,19 +1,7 @@
 import { assert } from "../../../assert.js";
+import { TET_FACE_VERTICES_BY_OPPOSITE, TET_FLIP_32_LAYOUTS } from "./tetrahedral_flip_layouts.js";
 import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
 
-/**
- * Face-vertex layout for a positively-oriented tet: for vertex slot i, the
- * face opposite has these slot indices in counter-clockwise-from-outside
- * order. Identical to the table in tetrahedral_mesh_flip_23.js; kept local
- * for module independence.
- */
-const FACE_VERTICES_BY_OPPOSITE = [
-    [1, 3, 2], // opposite v0
-    [0, 2, 3], // opposite v1
-    [0, 3, 1], // opposite v2
-    [0, 1, 2], // opposite v3
-];
-
 /**
  * Perform a 3-2 flip: three tetrahedra sharing a common edge collapse into
  * two tetrahedra sharing the triangle face that was previously bounded by
@@ -103,7 +91,7 @@ export function tetrahedral_mesh_flip_32(mesh, t1, t2, t3, out) {
     // direction. v_missing then sits between v_Y and v_X in that same CCW
     // cycle (i.e. it's v_X's CCW-prev, or equivalently v_Y's CCW-next).
     // -----------------------------------------------------------------
-    const face_opp_b = FACE_VERTICES_BY_OPPOSITE[slot_b_in_t1];
+    const face_opp_b = TET_FACE_VERTICES_BY_OPPOSITE[slot_b_in_t1];
     const face_v = [
         mesh.getVertexIndex(t1, face_opp_b[0]),
         mesh.getVertexIndex(t1, face_opp_b[1]),
@@ -191,15 +179,19 @@ export function tetrahedral_mesh_flip_32(mesh, t1, t2, t3, out) {
     //   new_tet_b = (v_X, v_Y, v_missing, v_b)  → face opp v_b is
     //               (v_X, v_Y, v_missing) CCW from outside (= CCW from v_a view)
     // -----------------------------------------------------------------
-    mesh.setVertexIndex(new_tet_a, 0, v_X);
-    mesh.setVertexIndex(new_tet_a, 1, v_missing);
-    mesh.setVertexIndex(new_tet_a, 2, v_Y);
-    mesh.setVertexIndex(new_tet_a, 3, v_a);
+    // Written once, in TET_FLIP_32_LAYOUTS, because tetrahedral_mesh_improve_quality scores a candidate
+    // flip against the same orderings without performing it. The neighbour links below are derived from
+    // them.
+    const operands = [v_X, v_Y, v_missing, v_a, v_b];
+    const new_tets = [new_tet_a, new_tet_b];
 
-    mesh.setVertexIndex(new_tet_b, 0, v_X);
-    mesh.setVertexIndex(new_tet_b, 1, v_Y);
-    mesh.setVertexIndex(new_tet_b, 2, v_missing);
-    mesh.setVertexIndex(new_tet_b, 3, v_b);
+    for (let i = 0; i < 2; i++) {
+        const layout = TET_FLIP_32_LAYOUTS[i];
+
+        for (let slot = 0; slot < 4; slot++) {
+            mesh.setVertexIndex(new_tets[i], slot, operands[layout[slot]]);
+        }
+    }
 
     // -----------------------------------------------------------------
     // Step 9: neighbour links.

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_improve_quality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_improve_quality.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,gFApBW,YAAY,GAAC,MAAM,EAAE,YACrB;IACV,cAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAoB,CAAC,EAAE,OAAO,CAAC;CAC5B,GACS;IACZ,UAAc,EAAE,MAAM,CAAC;IACvB,oBAAwB,EAAE,MAAM,CAAC;IACjC,mBAAuB,EAAE,MAAM,CAAC;IAChC,kBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAqB,EAAE,MAAM,CAAC;IAC9B,kBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAqB,EAAE,MAAM,CAAC;CAC3B,CA8OH"}
+{"version":3,"file":"tetrahedral_mesh_improve_quality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_improve_quality.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,gFApBW,YAAY,GAAC,MAAM,EAAE,YACrB;IACV,cAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAoB,CAAC,EAAE,OAAO,CAAC;CAC5B,GACS;IACZ,UAAc,EAAE,MAAM,CAAC;IACvB,oBAAwB,EAAE,MAAM,CAAC;IACjC,mBAAuB,EAAE,MAAM,CAAC;IAChC,kBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAqB,EAAE,MAAM,CAAC;IAC9B,kBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAqB,EAAE,MAAM,CAAC;CAC3B,CAwQH"}