@woosh/meep-engine 2.133.3 → 2.134.0

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

@@ -0,0 +1,307 @@
+import { vec3 } from "gl-matrix";
+import { EPSILON } from "../../../../../math/EPSILON.js";
+import { fabsf } from "../../../../../math/fabsf.js";
+
+const scratch_m3 = new Float32Array(9);
+
+/**
+ * Quadric Error Metric
+ * Upper-triangular portion of a symmetric 4x4 matrix encoding a quadric form.
+ *
+ * Layout (10 elements):
+ *   [0]=a2 [1]=ab [2]=ac [3]=ad
+ *          [4]=b2 [5]=bc [6]=bd
+ *                 [7]=c2 [8]=cd
+ *                        [9]=d2
+ */
+export class Quadric3 extends Float64Array {
+    constructor() {
+        super(10);
+    }
+
+    get a2() {
+        return this[0];
+    }
+
+    set a2(v) {
+        this[0] = v;
+    }
+
+    get ab() {
+        return this[1];
+    }
+
+    set ab(v) {
+        this[1] = v;
+    }
+
+    get ac() {
+        return this[2];
+    }
+
+    set ac(v) {
+        this[2] = v;
+    }
+
+    get ad() {
+        return this[3];
+    }
+
+    set ad(v) {
+        this[3] = v;
+    }
+
+    get b2() {
+        return this[4];
+    }
+
+    set b2(v) {
+        this[4] = v;
+    }
+
+    get bc() {
+        return this[5];
+    }
+
+    set bc(v) {
+        this[5] = v;
+    }
+
+    get bd() {
+        return this[6];
+    }
+
+    set bd(v) {
+        this[6] = v;
+    }
+
+    get c2() {
+        return this[7];
+    }
+
+    set c2(v) {
+        this[7] = v;
+    }
+
+    get cd() {
+        return this[8];
+    }
+
+    set cd(v) {
+        this[8] = v;
+    }
+
+    get d2() {
+        return this[9];
+    }
+
+    set d2(v) {
+        this[9] = v;
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} result
+     */
+    toVector3(result) {
+        result[0] = this[3];
+        result[1] = this[6];
+        result[2] = this[8];
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     */
+    toTensorM3(m3) {
+        const ab = this[1];
+        const ac = this[2];
+        const bc = this[5];
+
+        m3[0] = this[0];
+        m3[1] = ab;
+        m3[2] = ac;
+
+        m3[3] = ab;
+        m3[4] = this[4];
+        m3[5] = bc;
+
+        m3[6] = ac;
+        m3[7] = bc;
+        m3[8] = this[7];
+    }
+
+    /**
+     * Equivalent to taking a tensor followed by matrix inversion
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     * @param {number} epsilon
+     * @returns {boolean} whether operation was successful or not
+     */
+    toTensorM3Inverse(m3, epsilon) {
+        const a2 = this[0];
+        const ab = this[1];
+        const ac = this[2];
+        const b2 = this[4];
+        const bc = this[5];
+        const c2 = this[7];
+
+        const det = a2 * (b2 * c2 - bc * bc) -
+            ab * (ab * c2 - ac * bc) +
+            ac * (ab * bc - ac * b2);
+
+        if (fabsf(det) > epsilon) {
+            // avoid division by zero
+
+            const invdet = 1.0 / det;
+
+            m3[0] = (b2 * c2 - bc * bc) * invdet;
+            m3[3] = (bc * ac - ab * c2) * invdet;
+            m3[6] = (ab * bc - b2 * ac) * invdet;
+
+            m3[1] = (ac * bc - ab * c2) * invdet;
+            m3[4] = (a2 * c2 - ac * ac) * invdet;
+            m3[7] = (ab * ac - a2 * bc) * invdet;
+
+            m3[2] = (ab * bc - ac * b2) * invdet;
+            m3[5] = (ac * ab - a2 * bc) * invdet;
+            m3[8] = (a2 * b2 - ab * ab) * invdet;
+
+            return true;
+        }
+
+        // determinant is zero, matrix is singular, cannot invert
+
+        return false;
+    }
+
+    /**
+     * Set from plane expressed as a 4 component vector
+     * @param {number} x plane normal
+     * @param {number} y plane normal
+     * @param {number} z plane normal
+     * @param {number} w plane offset
+     */
+    setFromVector4(x, y, z, w) {
+        this[0] = x * x;
+        this[1] = x * y;
+        this[2] = x * z;
+        this[3] = x * w;
+
+        this[4] = y * y;
+        this[5] = y * z;
+        this[6] = y * w;
+
+        this[7] = z * z;
+        this[8] = z * w;
+
+        this[9] = w * w;
+    }
+
+    /**
+     * Squared distance from the given point to plane encoded by the quadric
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    evaluate(x, y, z) {
+        // Evaluate vAv + 2bv + c
+
+        return (x * x * this[0]) + (2 * x * y * this[1]) + (2 * x * z * this[2]) + (2 * x * this[3])    // A
+            + (y * y * this[4]) + (2 * y * z * this[5]) + (2 * y * this[6])                             // B
+            + (z * z * this[7]) + (2 * z * this[8])                                                     // C
+            + this[9];                                                                                  // D
+    }
+
+    /**
+     * Find the optimal vertex position based on the quadric
+     *
+     * @param {number[]} out vector3
+     * @returns {boolean}
+     */
+    optimize(out) {
+
+        // Based on Blender's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
+
+        if (this.toTensorM3Inverse(scratch_m3, EPSILON)) {
+
+            this.toVector3(out);
+
+            vec3.transformMat3(out, out, scratch_m3);
+            vec3.negate(out, out);
+
+            return true;
+        }
+
+        return false;
+
+    }
+
+    /**
+     *
+     * @param {Quadric3} Q
+     */
+    add(Q) {
+        this[0] += Q[0];
+        this[1] += Q[1];
+        this[2] += Q[2];
+        this[3] += Q[3];
+        this[4] += Q[4];
+        this[5] += Q[5];
+        this[6] += Q[6];
+        this[7] += Q[7];
+        this[8] += Q[8];
+        this[9] += Q[9];
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    multiplyScalar(v) {
+        this[0] *= v;
+        this[1] *= v;
+        this[2] *= v;
+        this[3] *= v;
+        this[4] *= v;
+        this[5] *= v;
+        this[6] *= v;
+        this[7] *= v;
+        this[8] *= v;
+        this[9] *= v;
+    }
+
+    /**
+     *
+     * @returns {Quadric3}
+     */
+    clone() {
+        const r = new Quadric3();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {Quadric3} other
+     */
+    copy(other) {
+        this.set(other);
+    }
+
+    /**
+     * Set all matrix values to 0
+     */
+    clear() {
+        this.fill(0);
+    }
+}
+
+/**
+ * Useful for type checking
+ * @readonly
+ * @type {boolean}
+ */
+Quadric3.prototype.isQuadric3 = true;

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

@@ -1,25 +1,25 @@
 /**
  *
- * @param {Map<number, Quadratic3>} destination
- * @param {Map<number, Quadratic3>} source
+ * @param {Map<number, Quadric3>} destination
+ * @param {Map<number, Quadric3>} source
  * @param {TopoMesh} mesh
  */
-export function deep_copy_vertex_quadratics(destination: Map<number, Quadratic3>, source: Map<number, Quadratic3>, mesh: TopoMesh): void;
+export function deep_copy_vertex_quadratics(destination: Map<number, Quadric3>, source: Map<number, Quadric3>, mesh: TopoMesh): void;
 /**
  *
  * @param {TopoMesh} mesh
  * @param {TopoEdge[]} border_set
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {number} [weight]
  */
-export function apply_border_penalties_to_vertex_quadrics(mesh: TopoMesh, border_set: TopoEdge[], vertex_quadratics: Map<number, Quadratic3>, weight?: number): void;
+export function apply_border_penalties_to_vertex_quadrics(mesh: TopoMesh, border_set: TopoEdge[], vertex_quadratics: Map<number, Quadric3>, weight?: number): void;
 /**
  *
  * @param {TopoMesh} mesh
- * @param {Map<number, Quadratic3>} quadratics VertexID -> Quadratic map
+ * @param {Map<number, Quadric3>} quadratics VertexID -> Quadratic map
  * @param {boolean} [use_triangle_area]
  * @param {boolean} [use_border_constraints]
  */
 export function build_vertex_quadratics({ mesh, quadratics, use_triangle_area, use_border_constraints }: TopoMesh): void;
-import { Quadratic3 } from "./Quadratic3.js";
+import { Quadric3 } from "./Quadric3.js";
 //# sourceMappingURL=build_vertex_quadratics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build_vertex_quadratics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,yDAJW,IAAI,MAAM,EAAE,UAAU,CAAC,UACvB,IAAI,MAAM,EAAE,UAAU,CAAC,wBAgBjC;AA8CD;;;;;;GAMG;AACH,sFAJW,UAAU,qBACV,IAAI,MAAM,EAAE,UAAU,CAAC,WACvB,MAAM,QAQhB;AAED;;;;;;GAMG;AACH,yHAwDC;2BAtJ0B,iBAAiB"}
+{"version":3,"file":"build_vertex_quadratics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,yDAJW,IAAI,MAAM,EAAE,QAAQ,CAAC,UACrB,IAAI,MAAM,EAAE,QAAQ,CAAC,wBAgB/B;AA8CD;;;;;;GAMG;AACH,sFAJW,UAAU,qBACV,IAAI,MAAM,EAAE,QAAQ,CAAC,WACrB,MAAM,QAQhB;AA2BD;;;;;;GAMG;AACH,yHAwDC;yBA1KwB,eAAe"}

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

@@ -1,14 +1,15 @@
-import { Quadratic3 } from "./Quadratic3.js";
-import { tm_face_area } from "../../tm_face_area.js";
-import { assert } from "../../../../../assert.js";
-import { tm_face_normal } from "../../tm_face_normal.js";
 import { vec3 } from "gl-matrix";
+import { assert } from "../../../../../assert.js";
+import { v3_dot } from "../../../../vec3/v3_dot.js";
 import { query_edge_is_boundary } from "../../query/query_edge_is_boundary.js";
+import { tm_face_area } from "../../tm_face_area.js";
+import { tm_face_normal } from "../../tm_face_normal.js";
+import { Quadric3 } from "./Quadric3.js";
 
 /**
  *
- * @param {Map<number, Quadratic3>} destination
- * @param {Map<number, Quadratic3>} source
+ * @param {Map<number, Quadric3>} destination
+ * @param {Map<number, Quadric3>} source
  * @param {TopoMesh} mesh
  */
 export function deep_copy_vertex_quadratics(destination, source, mesh) {
@@ -31,7 +32,7 @@ export function deep_copy_vertex_quadratics(destination, source, mesh) {
  * @see "Boundary and Texture Preserving Mesh Simplification Algorithm for Virtual Reality" by Kanchan Bahirat et.al. University of Texas/Dallas
  * @param {TopoEdge} edge
  * @param {number} weight
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  */
 function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics) {
     const v0 = edge.v0;
@@ -57,7 +58,7 @@ function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics
 
     const d = -vec3.dot(abc, v0);
 
-    const constraint = new Quadratic3();
+    const constraint = new Quadric3();
     constraint.setFromVector4(abc[0], abc[1], abc[2], d);
     constraint.multiplyScalar(vec3.length(edge_vector) * weight);
     // constraint.multiplyScalar(weight);
@@ -74,7 +75,7 @@ function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics
  *
  * @param {TopoMesh} mesh
  * @param {TopoEdge[]} border_set
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {number} [weight]
  */
 export function apply_border_penalties_to_vertex_quadrics(mesh, border_set, vertex_quadratics, weight = 10) {
@@ -85,10 +86,35 @@ export function apply_border_penalties_to_vertex_quadrics(mesh, border_set, vert
     }
 }
 
+/**
+ *
+ * @param {Quadric3} quadric
+ * @param {TopoTriangle} face
+ */
+function quadric_set_from_face(quadric, face){
+    const v0 = face.vertices[0];
+
+    // compute triangle's plane
+    face.computeNormal();
+
+    // compute plane offset
+    const normal_x = face.normal[0];
+    const normal_y = face.normal[1];
+    const normal_z = face.normal[2];
+
+    const plane_constant = -v3_dot(
+        normal_x, normal_y, normal_z,
+
+        v0.x, v0.y, v0.z
+    );
+
+    quadric.setFromVector4(normal_x, normal_y, normal_z, plane_constant);
+}
+
 /**
  *
  * @param {TopoMesh} mesh
- * @param {Map<number, Quadratic3>} quadratics VertexID -> Quadratic map
+ * @param {Map<number, Quadric3>} quadratics VertexID -> Quadratic map
  * @param {boolean} [use_triangle_area]
  * @param {boolean} [use_border_constraints]
  */
@@ -108,19 +134,19 @@ export function build_vertex_quadratics({
     for (i = 0; i < mesh_vertex_count; i++) {
         const mesh_vertex = mesh_vertices[i];
 
-        const vertex_quadratic = new Quadratic3();
+        const vertex_quadratic = new Quadric3();
 
         quadratics.set(mesh_vertex.index, vertex_quadratic);
     }
 
     // compute values for quadratics
-    const q = new Quadratic3();
+    const q = new Quadric3();
 
     const faces = mesh.getFaces();
 
     for (face of faces) {
 
-        q.setFromFace(face);
+        quadric_set_from_face(q,face);
 
         if (use_triangle_area) {
             const triangle_area = tm_face_area(face);

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

@@ -3,8 +3,8 @@
  * @param {TopoVertex} v0
  * @param {TopoVertex} v1
  * @param {TopoVertex} target where to collapse v0 and v1 to
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @returns {number}
  */
-export function compute_edge_collapse_cost_quadratic(v0: TopoVertex, v1: TopoVertex, target: TopoVertex, quadratics: Map<number, Quadratic3>): number;
+export function compute_edge_collapse_cost_quadratic(v0: TopoVertex, v1: TopoVertex, target: TopoVertex, quadratics: Map<number, Quadric3>): number;
 //# sourceMappingURL=compute_edge_collapse_cost_quadratic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compute_edge_collapse_cost_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qHAHW,IAAI,MAAM,aAAY,GACpB,MAAM,CAqBlB"}
+{"version":3,"file":"compute_edge_collapse_cost_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qHAHW,IAAI,MAAM,WAAU,GAClB,MAAM,CAqBlB"}

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

@@ -3,7 +3,7 @@
  * @param {TopoVertex} v0
  * @param {TopoVertex} v1
  * @param {TopoVertex} target where to collapse v0 and v1 to
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @returns {number}
  */
 export function compute_edge_collapse_cost_quadratic(

package/src/core/geom/3d/topology/simplify/simplifyTopoMesh.d.ts

@@ -8,10 +8,10 @@ export function extract_edge_cost(edge: EdgeCollapseCandidate): number;
  * @param {BinaryHeap<EdgeCollapseCandidate>} heap
  * @param {TopoMesh} mesh
  * @param {Map<TopoEdge, EdgeCollapseCandidate>} edge_to_collapse_map
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {Set<number>} restricted_vertices
  */
-export function collapse_edges(number_faces_to_remove: number, heap: BinaryHeap<EdgeCollapseCandidate>, mesh: TopoMesh, edge_to_collapse_map: Map<TopoEdge, EdgeCollapseCandidate>, vertex_quadratics: Map<number, Quadratic3>, restricted_vertices: Set<number>): void;
+export function collapse_edges(number_faces_to_remove: number, heap: BinaryHeap<EdgeCollapseCandidate>, mesh: TopoMesh, edge_to_collapse_map: Map<TopoEdge, EdgeCollapseCandidate>, vertex_quadratics: Map<number, Quadric3>, restricted_vertices: Set<number>): void;
 /**
  * Simplifies a given topology mesh by reducing number of faces. Preserves original vertices
  * NOTE: preserves outline of the mesh, that is the open edge

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

@@ -1 +1 @@
-{"version":3,"file":"simplifyTopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,wCAFW,qBAAqB,UAI/B;AAGD;;;;;;;GAOG;AACH,uDAPW,MAAM,QACN,WAAW,qBAAqB,CAAC,wCAEjC,cAAc,qBAAqB,CAAC,qBACpC,IAAI,MAAM,aAAa,uBACvB,IAAI,MAAM,CAAC,QAyKrB;AAED;;;;;;;GAOG;AACH,sEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAwDrB;sCAhQqC,4BAA4B;uBAL3C,2CAA2C"}
+{"version":3,"file":"simplifyTopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,wCAFW,qBAAqB,UAI/B;AAGD;;;;;;;GAOG;AACH,uDAPW,MAAM,QACN,WAAW,qBAAqB,CAAC,wCAEjC,cAAc,qBAAqB,CAAC,qBACpC,IAAI,MAAM,WAAW,uBACrB,IAAI,MAAM,CAAC,QAyKrB;AAED;;;;;;;GAOG;AACH,sEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAwDrB;sCAhQqC,4BAA4B;uBAL3C,2CAA2C"}

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

@@ -26,7 +26,7 @@ export function extract_edge_cost(edge) {
  * @param {BinaryHeap<EdgeCollapseCandidate>} heap
  * @param {TopoMesh} mesh
  * @param {Map<TopoEdge, EdgeCollapseCandidate>} edge_to_collapse_map
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {Set<number>} restricted_vertices
  */
 export function collapse_edges(
@@ -231,7 +231,7 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
 
     /**
      *
-     * @type {Map<number, Quadratic3>}
+     * @type {Map<number, Quadric3>}
      */
     const vertex_quadratics = new Map();
 

package/src/core/geom/3d/topology/simplify/simplifyTopoMesh2.d.ts

@@ -3,10 +3,10 @@
  * @param {Iterable<TopoEdge>} edges
  * @param {Set<number>} restricted_vertices
  * @param {Uint32Heap} heap
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {Map<number,TopoEdge>} edge_lookup
  */
-export function edge_collapse_populate_heap(edges: Iterable<TopoEdge>, restricted_vertices: Set<number>, heap: Uint32Heap, vertex_quadratics: Map<number, Quadratic3>, edge_lookup: Map<number, TopoEdge>): void;
+export function edge_collapse_populate_heap(edges: Iterable<TopoEdge>, restricted_vertices: Set<number>, heap: Uint32Heap, vertex_quadratics: Map<number, Quadric3>, edge_lookup: Map<number, TopoEdge>): void;
 /**
  *
  * @param {TopoMesh} mesh
@@ -14,9 +14,9 @@ export function edge_collapse_populate_heap(edges: Iterable<TopoEdge>, restricte
  * @param {Uint32Heap} heap
  * @param {Map<number,TopoEdge>} edge_lookup
  * @param {Set<number>} restricted_vertices
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  */
-export function edge_collapse_reduce_face_count(mesh: TopoMesh, num_faces_to_remove: number, heap: Uint32Heap, edge_lookup: Map<number, TopoEdge>, restricted_vertices: Set<number>, vertex_quadratics: Map<number, Quadratic3>): void;
+export function edge_collapse_reduce_face_count(mesh: TopoMesh, num_faces_to_remove: number, heap: Uint32Heap, edge_lookup: Map<number, TopoEdge>, restricted_vertices: Set<number>, vertex_quadratics: Map<number, Quadric3>): void;
 /**
  * Simplifies a given topology mesh by reducing number of faces. Preserves original vertices
  * NOTE: preserves outline of the mesh, that is the open edge

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

@@ -1 +1 @@
-{"version":3,"file":"simplifyTopoMesh2.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh2.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,mDANW,kBAAkB,uBAClB,IAAI,MAAM,CAAC,QACX,UAAU,qBACV,IAAI,MAAM,aAAa,eACvB,IAAI,MAAM,WAAU,QAsB9B;AAED;;;;;;;;GAQG;AACH,qFANW,MAAM,QACN,UAAU,eACV,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,aAAa,QAgCjC;AAED;;;;;;;GAOG;AACH,uEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAgCrB;2BAtH0B,2CAA2C"}
+{"version":3,"file":"simplifyTopoMesh2.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh2.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,mDANW,kBAAkB,uBAClB,IAAI,MAAM,CAAC,QACX,UAAU,qBACV,IAAI,MAAM,WAAW,eACrB,IAAI,MAAM,WAAU,QAsB9B;AAED;;;;;;;;GAQG;AACH,qFANW,MAAM,QACN,UAAU,eACV,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,WAAW,QAgC/B;AAED;;;;;;;GAOG;AACH,uEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAgCrB;2BAtH0B,2CAA2C"}

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

@@ -1,18 +1,18 @@
 import { Uint32Heap } from "../../../../collection/heap/Uint32Heap.js";
-import { build_vertex_quadratics } from "./quadratic/build_vertex_quadratics.js";
+import { max2 } from "../../../../math/max2.js";
 import {
     compute_edge_collapse_cost,
     decimate_edge_collapse_snap,
     edge_collapse_pick_target_vertex
 } from "./decimate_edge_collapse_snap.js";
-import { max2 } from "../../../../math/max2.js";
+import { build_vertex_quadratics } from "./quadratic/build_vertex_quadratics.js";
 
 /**
  *
  * @param {Iterable<TopoEdge>} edges
  * @param {Set<number>} restricted_vertices
  * @param {Uint32Heap} heap
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {Map<number,TopoEdge>} edge_lookup
  */
 export function edge_collapse_populate_heap(edges, restricted_vertices, heap, vertex_quadratics, edge_lookup) {
@@ -44,7 +44,7 @@ export function edge_collapse_populate_heap(edges, restricted_vertices, heap, ve
  * @param {Uint32Heap} heap
  * @param {Map<number,TopoEdge>} edge_lookup
  * @param {Set<number>} restricted_vertices
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  */
 export function edge_collapse_reduce_face_count(mesh, num_faces_to_remove, heap, edge_lookup, restricted_vertices, vertex_quadratics) {
     const mesh_faces = mesh.getFaces();
@@ -99,7 +99,7 @@ export function simplifyTopoMesh2(mesh, num_faces_to_remove, restricted_vertices
     const heap = new Uint32Heap(mesh.getEdges().size);
     /**
      *
-     * @type {Map<number, Quadratic3>}
+     * @type {Map<number, Quadric3>}
      */
     const vertex_quadratics = new Map();
 

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

@@ -0,0 +1,8 @@
+/**
+ * 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: BinaryTopology): void;
+//# sourceMappingURL=bt_mesh_compute_face_normals.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,56 @@
+import { assert } from "../../../../../../assert.js";
+import { v3_compute_triangle_normal } from "../../../../triangle/v3_compute_triangle_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));
+
+        v3_compute_triangle_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);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Compute a per-vertex quadric error metric from every allocated triangular face.
+ *
+ * For each triangular face the supporting plane (n, d) is derived from its loop
+ * vertices; the corresponding quadric is then accumulated onto each of those
+ * three vertices' Quadric3. Non-triangular faces are skipped.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Quadric3[]} Array indexed by vertex ID. Entries for unallocated
+ *     vertex slots are `undefined`.
+ */
+export function bt_mesh_compute_vertex_quadratics(mesh: BinaryTopology): Quadric3[];
+import { Quadric3 } from "../../../simplify/quadratic/Quadric3.js";
+//# sourceMappingURL=bt_mesh_compute_vertex_quadratics.d.ts.map