@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -1,260 +1,251 @@
-import { bt_edge_count_faces } from "../query/bt_edge_count_faces.js";
-import { quadric3_set_from_plane_through_point } from "../../../../quadric/quadric3_set_from_plane_through_point.js";
-import { assert } from "../../../../../../assert.js";
-import { v3_dot } from "../../../../../vec3/v3_dot.js";
-import { tri3_area } from "../../../../triangle/tri3_area.js";
-import { tri3_compute_normal } from "../../../../triangle/tri3_compute_normal.js";
-import { Quadric3 } from "../../../../quadric/Quadric3.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
-
-const scratch_coord_a = new Float32Array(3);
-const scratch_coord_b = new Float32Array(3);
-const scratch_coord_c = new Float32Array(3);
-const scratch_normal = new Float32Array(3);
-const boundary_quadric = new Quadric3();
-
-/**
- * How much a boundary constraint plane weighs against one face plane **of the same area**.
- *
- * Three, measured. A face-plane quadric alone says nothing about a vertex sliding *within* the
- * surface, which is exactly what an open edge does when it erodes, so without this term a boundary
- * retreats at a recorded cost of zero. What the weight controls is how loudly it says so: the error
- * a vertex reports is the mean over its planes, so a boundary vertex with a handful of faces and two
- * constraint planes would have the retreat diluted threefold at weight one. Three brings it back to
- * roughly the displacement itself, while leaving the boundary free enough to erode at all — which
- * it must, or a mesh made of open shells has no coarse form and no root.
- *
- * It is a ratio against a face, so it is applied on top of the face's own area weight rather than
- * instead of it. Three flat is a number of square metres, which is not a ratio at all: the same
- * border would weigh a millionth of its fan on a model authored in millimetres and a million times
- * it on one authored in kilometres, and the measurement above would hold for neither.
- *
- * @readonly
- * @type {number}
- */
-const BOUNDARY_WEIGHT = 3;
-
-/**
- * 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.
- *
- * **Each plane weighs the surface standing behind it, not one.** What a vertex reports is the mean
- * over its planes ({@link Quadric3#distance}), and a mean over a count is a statement about how the
- * surface was *cut* rather than about the surface: cutting one face in two along its own plane adds
- * no surface and the metric hears the same plane twice, so a finely tessellated patch outvotes a
- * coarse one many times its size. Weighing each plane by its triangle's area is what makes the mean
- * an average over the surface, and it is what makes an in-plane subdivision — which says nothing new
- * — change nothing.
- *
- * The weights are **areas as a multiple of this mesh's own mean triangle**, not areas. A ratio is
- * what every other number here is stated against: {@link BOUNDARY_WEIGHT} is three *faces*, and the
- * attribute quadric a virtual-geometry build sums with these weighs one per triangle and says so
- * ({@link quadric_attribute_set_from_triangle}) — both of which are answers to "how much is a face
- * worth", and neither survives the slot becoming square metres. It costs nothing that matters: a
- * mean divides the weights out again, so what a vertex reports is identical either way, and
- * {@link quadric3_optimize} is scale-invariant, so placement is too.
- *
- * A triangle with no area is skipped entirely rather than weighed at zero. It has no plane —
- * {@link tri3_compute_normal} hands it an arbitrary direction — so it neither contributes one nor
- * counts towards the mean it would otherwise drag down.
- *
- * @param {BinaryTopology} mesh
- * @returns {Quadric3[]} Array indexed by vertex ID. Entries for unallocated
- *     vertex slots are `undefined`.
- */
-export function bt_mesh_compute_vertex_quadrics(mesh) {
-    assert.defined(mesh, 'mesh');
-    assert.notNull(mesh, 'mesh');
-
-    const vertex_pool = mesh.vertices;
-    const vertex_count = vertex_pool.size;
-
-    const quadratics = new Array(vertex_count);
-
-    for (let v = 0; v < vertex_count; v++) {
-        if (vertex_pool.is_allocated(v)) {
-            quadratics[v] = new Quadric3();
-        }
-    }
-
-    const face_pool = mesh.faces;
-    const face_count = face_pool.size;
-
-    const q = new Quadric3();
-
-    // The mesh's own scale, for the normalization below. Accumulated as the faces go by rather than
-    // swept for beforehand, since the loop below already has every area it needs.
-    let total_area = 0;
-    let triangle_count = 0;
-
-    for (let f = 0; f < face_count; f++) {
-        if (!face_pool.is_allocated(f)) {
-            continue;
-        }
-
-        const la = mesh.face_read_loop(f);
-
-        if (la === NULL_POINTER) {
-            continue;
-        }
-
-        const lb = mesh.loop_read_next(la);
-        const lc = mesh.loop_read_next(lb);
-
-        // Skip non-triangles
-        if (mesh.loop_read_next(lc) !== la) {
-            continue;
-        }
-
-        const va = mesh.loop_read_vertex(la);
-        const vb = mesh.loop_read_vertex(lb);
-        const vc = mesh.loop_read_vertex(lc);
-
-        mesh.vertex_read_coordinate(scratch_coord_a, 0, va);
-        mesh.vertex_read_coordinate(scratch_coord_b, 0, vb);
-        mesh.vertex_read_coordinate(scratch_coord_c, 0, vc);
-
-        const area = tri3_area(
-            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]
-        );
-
-        if (area === 0) {
-            continue;
-        }
-
-        total_area += area;
-        triangle_count++;
-
-        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]
-        );
-
-        const nx = scratch_normal[0];
-        const ny = scratch_normal[1];
-        const nz = scratch_normal[2];
-
-        quadric3_set_from_plane_through_point(
-            q, 0,
-            nx, ny, nz,
-            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
-        );
-
-        // Weight and matrix together, which is what {@link quadric3_scale} is for: the plane counts
-        // for its area in the sum *and* declares that it does, so the mean stays a length.
-        q.multiplyScalar(area);
-
-        quadratics[va].add(q);
-        quadratics[vb].add(q);
-        quadratics[vc].add(q);
-
-        add_boundary_constraints(mesh, quadratics, f, nx, ny, nz, area);
-    }
-
-    if (triangle_count > 0) {
-        // Areas into multiples of the mean triangle. One pass at the end rather than a pass for the
-        // mean before the accumulation: scaling is linear and uniform, so dividing every quadric
-        // here is dividing every plane's weight there.
-        const of_a_mean_triangle = triangle_count / total_area;
-
-        for (let v = 0; v < vertex_count; v++) {
-            const quadric = quadratics[v];
-
-            if (quadric !== undefined) {
-                quadric.multiplyScalar(of_a_mean_triangle);
-            }
-        }
-    }
-
-    return quadratics;
-}
-/**
- * Constrain the face's open edges, so that the surface's border is not free to retreat for nothing.
- *
- * A face-plane quadric measures how far a vertex has moved *off* the surface, and by construction
- * says nothing about it moving *along* it. For an interior vertex that is right — the surface
- * continues in every direction and sliding within it is genuinely free. For a vertex on a border it
- * is badly wrong: sliding inward destroys surface that is not there to replace it, and the metric
- * records nothing at all. Garland and Heckbert's answer, and the one here: for each open edge, add
- * the plane through it perpendicular to its face. The vertex is then pinned in the two directions
- * that matter and free in the one that does not — along the border, where sliding really is free.
- *
- * "Open" means an edge with any number of faces other than two. One face is a border. Three or more
- * is non-manifold, where the surface branches and moving the seam is no more free than moving a
- * border; each incident face contributes its own constraint, which is the right answer for a seam
- * that bends.
- *
- * Without this, a mesh with borders coarsens at a recorded error of zero however much of it is eaten
- * away — and zero is monotonic, so nothing downstream can tell. That is not an optimistic number, it
- * is a wrong one.
- *
- * @param {BinaryTopology} mesh
- * @param {Quadric3[]} quadratics indexed by vertex id
- * @param {number} face
- * @param {number} nx face normal, unit
- * @param {number} ny
- * @param {number} nz
- * @param {number} area of the face, which the constraint carries so that it stays
- *     {@link BOUNDARY_WEIGHT} times a face rather than a fixed number of square metres
- */
-function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz, area) {
-    const first = mesh.face_read_loop(face);
-
-    let loop = first;
-
-    do {
-        const edge = mesh.loop_read_edge(loop);
-
-        if (bt_edge_count_faces(mesh, edge) === 2) {
-            loop = mesh.loop_read_next(loop);
-
-            continue;
-        }
-
-        const v1 = mesh.edge_read_vertex1(edge);
-        const v2 = mesh.edge_read_vertex2(edge);
-
-        mesh.vertex_read_coordinate(scratch_coord_a, 0, v1);
-        mesh.vertex_read_coordinate(scratch_coord_b, 0, v2);
-
-        const ex = scratch_coord_b[0] - scratch_coord_a[0];
-        const ey = scratch_coord_b[1] - scratch_coord_a[1];
-        const ez = scratch_coord_b[2] - scratch_coord_a[2];
-
-        // Perpendicular to the edge and to the face normal, so it lies *in* the face's plane and
-        // faces across the border. The face normal is unit and the cross product's length is the
-        // edge's, so dividing by that normalizes it.
-        const px = ey * nz - ez * ny;
-        const py = ez * nx - ex * nz;
-        const pz = ex * ny - ey * nx;
-
-        const length = Math.sqrt(px * px + py * py + pz * pz);
-
-        if (length === 0) {
-            // A degenerate edge, or one running along the face normal, which no plane describes.
-            loop = mesh.loop_read_next(loop);
-
-            continue;
-        }
-
-        quadric3_set_from_plane_through_point(
-            boundary_quadric, 0,
-            px / length, py / length, pz / length,
-            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
-        );
-
-        boundary_quadric.multiplyScalar(BOUNDARY_WEIGHT * area);
-
-        quadratics[v1].add(boundary_quadric);
-        quadratics[v2].add(boundary_quadric);
-
-        loop = mesh.loop_read_next(loop);
-    } while (loop !== first && loop !== NULL_POINTER);
-}
+import { bt_edge_count_faces } from "../query/bt_edge_count_faces.js";
+import { bt_face_read_triangle_vertices } from "../query/bt_face_read_triangle.js";
+import { quadric3_set_from_plane_through_point } from "../../../../quadric/quadric3_set_from_plane_through_point.js";
+import { assert } from "../../../../../../assert.js";
+import { tri3_area } from "../../../../triangle/tri3_area.js";
+import { tri3_compute_normal } from "../../../../triangle/tri3_compute_normal.js";
+import { Quadric3 } from "../../../../quadric/Quadric3.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+const scratch_vertices = new Uint32Array(3);
+const scratch_coord_a = new Float32Array(3);
+const scratch_coord_b = new Float32Array(3);
+const scratch_coord_c = new Float32Array(3);
+const scratch_normal = new Float32Array(3);
+const boundary_quadric = new Quadric3();
+
+/**
+ * How much a boundary constraint plane weighs against one face plane **of the same area**.
+ *
+ * Three, measured. A face-plane quadric alone says nothing about a vertex sliding *within* the
+ * surface, which is exactly what an open edge does when it erodes, so without this term a boundary
+ * retreats at a recorded cost of zero. What the weight controls is how loudly it says so: the error
+ * a vertex reports is the mean over its planes, so a boundary vertex with a handful of faces and two
+ * constraint planes would have the retreat diluted threefold at weight one. Three brings it back to
+ * roughly the displacement itself, while leaving the boundary free enough to erode at all — which
+ * it must, or a mesh made of open shells has no coarse form and no root.
+ *
+ * It is a ratio against a face, so it is applied on top of the face's own area weight rather than
+ * instead of it. Three flat is a number of square metres, which is not a ratio at all: the same
+ * border would weigh a millionth of its fan on a model authored in millimetres and a million times
+ * it on one authored in kilometres, and the measurement above would hold for neither.
+ *
+ * @readonly
+ * @type {number}
+ */
+const BOUNDARY_WEIGHT = 3;
+
+/**
+ * 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.
+ *
+ * **Each plane weighs the surface standing behind it, not one.** What a vertex reports is the mean
+ * over its planes ({@link Quadric3#distance}), and a mean over a count is a statement about how the
+ * surface was *cut* rather than about the surface: cutting one face in two along its own plane adds
+ * no surface and the metric hears the same plane twice, so a finely tessellated patch outvotes a
+ * coarse one many times its size. Weighing each plane by its triangle's area is what makes the mean
+ * an average over the surface, and it is what makes an in-plane subdivision — which says nothing new
+ * — change nothing.
+ *
+ * The weights are **areas as a multiple of this mesh's own mean triangle**, not areas. A ratio is
+ * what every other number here is stated against: {@link BOUNDARY_WEIGHT} is three *faces*, and the
+ * attribute quadric a virtual-geometry build sums with these weighs one per triangle and says so
+ * ({@link quadric_attribute_set_from_triangle}) — both of which are answers to "how much is a face
+ * worth", and neither survives the slot becoming square metres. It costs nothing that matters: a
+ * mean divides the weights out again, so what a vertex reports is identical either way, and
+ * {@link quadric3_optimize} is scale-invariant, so placement is too.
+ *
+ * A triangle with no area is skipped entirely rather than weighed at zero. It has no plane —
+ * {@link tri3_compute_normal} hands it an arbitrary direction — so it neither contributes one nor
+ * counts towards the mean it would otherwise drag down.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Quadric3[]} Array indexed by vertex ID. Entries for unallocated
+ *     vertex slots are `undefined`.
+ */
+export function bt_mesh_compute_vertex_quadrics(mesh) {
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+
+    const vertex_pool = mesh.vertices;
+    const vertex_count = vertex_pool.size;
+
+    const quadratics = new Array(vertex_count);
+
+    for (let v = 0; v < vertex_count; v++) {
+        if (vertex_pool.is_allocated(v)) {
+            quadratics[v] = new Quadric3();
+        }
+    }
+
+    const face_pool = mesh.faces;
+    const face_count = face_pool.size;
+
+    const q = new Quadric3();
+
+    // The mesh's own scale, for the normalization below. Accumulated as the faces go by rather than
+    // swept for beforehand, since the loop below already has every area it needs.
+    let total_area = 0;
+    let triangle_count = 0;
+
+    for (let f = 0; f < face_count; f++) {
+        if (!face_pool.is_allocated(f)) {
+            continue;
+        }
+
+        if (!bt_face_read_triangle_vertices(scratch_vertices, mesh, f)) {
+            continue;
+        }
+
+        const va = scratch_vertices[0];
+        const vb = scratch_vertices[1];
+        const vc = scratch_vertices[2];
+
+        mesh.vertex_read_coordinate(scratch_coord_a, 0, va);
+        mesh.vertex_read_coordinate(scratch_coord_b, 0, vb);
+        mesh.vertex_read_coordinate(scratch_coord_c, 0, vc);
+
+        const area = tri3_area(
+            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]
+        );
+
+        if (area === 0) {
+            continue;
+        }
+
+        total_area += area;
+        triangle_count++;
+
+        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]
+        );
+
+        const nx = scratch_normal[0];
+        const ny = scratch_normal[1];
+        const nz = scratch_normal[2];
+
+        quadric3_set_from_plane_through_point(
+            q, 0,
+            nx, ny, nz,
+            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
+        );
+
+        // Weight and matrix together, which is what {@link quadric3_scale} is for: the plane counts
+        // for its area in the sum *and* declares that it does, so the mean stays a length.
+        q.multiplyScalar(area);
+
+        quadratics[va].add(q);
+        quadratics[vb].add(q);
+        quadratics[vc].add(q);
+
+        add_boundary_constraints(mesh, quadratics, f, nx, ny, nz, area);
+    }
+
+    if (triangle_count > 0) {
+        // Areas into multiples of the mean triangle. One pass at the end rather than a pass for the
+        // mean before the accumulation: scaling is linear and uniform, so dividing every quadric
+        // here is dividing every plane's weight there.
+        const of_a_mean_triangle = triangle_count / total_area;
+
+        for (let v = 0; v < vertex_count; v++) {
+            const quadric = quadratics[v];
+
+            if (quadric !== undefined) {
+                quadric.multiplyScalar(of_a_mean_triangle);
+            }
+        }
+    }
+
+    return quadratics;
+}
+/**
+ * Constrain the face's open edges, so that the surface's border is not free to retreat for nothing.
+ *
+ * A face-plane quadric measures how far a vertex has moved *off* the surface, and by construction
+ * says nothing about it moving *along* it. For an interior vertex that is right — the surface
+ * continues in every direction and sliding within it is genuinely free. For a vertex on a border it
+ * is badly wrong: sliding inward destroys surface that is not there to replace it, and the metric
+ * records nothing at all. Garland and Heckbert's answer, and the one here: for each open edge, add
+ * the plane through it perpendicular to its face. The vertex is then pinned in the two directions
+ * that matter and free in the one that does not — along the border, where sliding really is free.
+ *
+ * "Open" means an edge with any number of faces other than two. One face is a border. Three or more
+ * is non-manifold, where the surface branches and moving the seam is no more free than moving a
+ * border; each incident face contributes its own constraint, which is the right answer for a seam
+ * that bends.
+ *
+ * Without this, a mesh with borders coarsens at a recorded error of zero however much of it is eaten
+ * away — and zero is monotonic, so nothing downstream can tell. That is not an optimistic number, it
+ * is a wrong one.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {Quadric3[]} quadratics indexed by vertex id
+ * @param {number} face
+ * @param {number} nx face normal, unit
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} area of the face, which the constraint carries so that it stays
+ *     {@link BOUNDARY_WEIGHT} times a face rather than a fixed number of square metres
+ */
+function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz, area) {
+    const first = mesh.face_read_loop(face);
+
+    let loop = first;
+
+    do {
+        const edge = mesh.loop_read_edge(loop);
+
+        if (bt_edge_count_faces(mesh, edge) === 2) {
+            loop = mesh.loop_read_next(loop);
+
+            continue;
+        }
+
+        const v1 = mesh.edge_read_vertex1(edge);
+        const v2 = mesh.edge_read_vertex2(edge);
+
+        mesh.vertex_read_coordinate(scratch_coord_a, 0, v1);
+        mesh.vertex_read_coordinate(scratch_coord_b, 0, v2);
+
+        const ex = scratch_coord_b[0] - scratch_coord_a[0];
+        const ey = scratch_coord_b[1] - scratch_coord_a[1];
+        const ez = scratch_coord_b[2] - scratch_coord_a[2];
+
+        // Perpendicular to the edge and to the face normal, so it lies *in* the face's plane and
+        // faces across the border. The face normal is unit and the cross product's length is the
+        // edge's, so dividing by that normalizes it.
+        const px = ey * nz - ez * ny;
+        const py = ez * nx - ex * nz;
+        const pz = ex * ny - ey * nx;
+
+        const length = Math.sqrt(px * px + py * py + pz * pz);
+
+        if (length === 0) {
+            // A degenerate edge, or one running along the face normal, which no plane describes.
+            loop = mesh.loop_read_next(loop);
+
+            continue;
+        }
+
+        quadric3_set_from_plane_through_point(
+            boundary_quadric, 0,
+            px / length, py / length, pz / length,
+            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
+        );
+
+        boundary_quadric.multiplyScalar(BOUNDARY_WEIGHT * area);
+
+        quadratics[v1].add(boundary_quadric);
+        quadratics[v2].add(boundary_quadric);
+
+        loop = mesh.loop_read_next(loop);
+    } while (loop !== first && loop !== NULL_POINTER);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_wedge_attribute_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_wedge_attribute_quadrics.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uFAXW,UAAU,MAAM,CAAC,cACjB,MAAM,WACN,UAAU,MAAM,CAAC,uBAEf,YAAY,CAmExB"}
+{"version":3,"file":"bt_mesh_compute_wedge_attribute_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_wedge_attribute_quadrics.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uFAXW,UAAU,MAAM,CAAC,cACjB,MAAM,WACN,UAAU,MAAM,CAAC,uBAEf,YAAY,CA0DxB"}