@woosh/meep-engine 3.27.0 → 3.29.0

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

@@ -233,6 +233,41 @@ export class BinaryDataBlock {
         );
     }
 
+    /**
+     * Do two records hold the same bytes?
+     *
+     * Bytes, not values, and that is the point: this is the test a *wedge* is defined by — a set of
+     * corners at one vertex that shade identically — and identity has to be exact for the grouping
+     * to be an equivalence relation. A tolerance is not transitive, so grouping by one would depend
+     * on the order the corners were visited in, and two runs over the same mesh could disagree.
+     *
+     * Every byte of the record, so a block gaining a layer needs nothing here.
+     *
+     * @param {number} a element id in this block
+     * @param {number} b element id in this block
+     * @returns {boolean}
+     */
+    record_equal(a, b) {
+        if (a === b) {
+            return true;
+        }
+
+        const record_size = this.#record_size;
+
+        const from_a = a * record_size;
+        const from_b = b * record_size;
+
+        const data = this.#data_uint8;
+
+        for (let offset = 0; offset < record_size; offset++) {
+            if (data[from_a + offset] !== data[from_b + offset]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Take on another block's layers and contents.
      *

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

@@ -0,0 +1,93 @@
+/**
+ * Which corners of a mesh shade as one.
+ *
+ * A **wedge** is a set of loops at one vertex that carry the same appearance. A vertex has one
+ * position and the topology says so; it does not have one *appearance*, and a hard edge or a texture
+ * seam is exactly a vertex whose corners disagree. This is the structure that lets them.
+ *
+ * Three things, and the split between them is the whole design:
+ *
+ * - **{@link of_loop} is never written after construction.** A collapse re-points a victim's loops
+ *   onto the survivor and leaves the loops themselves alone, so a corner's wedge id travels with it
+ *   for free. Nothing has to find a corner in order to move it.
+ * - **{@link parent} is a union-find**, and merging two wedges is a union. That is what makes the
+ *   previous point affordable: the ids a loop holds go stale, {@link find} resolves them, and no
+ *   pass over the loop pool is ever needed to keep them true.
+ * - **{@link first_of_vertex} and {@link next_of_wedge} are one intrusive list per vertex**, which
+ *   is what a collapse iterates. Two typed arrays rather than an array of arrays per vertex: a
+ *   frontier holds every vertex of a level, and on smooth geometry every one of those lists has
+ *   exactly one entry.
+ *
+ * Wedge ids need not be dense and need not agree with vertex ids. {@link bt_wedges_per_vertex}
+ * builds the degenerate set where they are vertex ids — one wedge per vertex, which is a mesh with
+ * no seams and is what every caller that does not care about appearance wants.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BtWedgeSet {
+    /**
+     * The wedge each loop belongs to, indexed by loop id. Read through {@link find}, never trusted
+     * raw: a merge leaves it naming a wedge that is no longer a root.
+     * @type {Uint32Array}
+     */
+    of_loop: Uint32Array;
+    /**
+     * Union-find over wedge ids. A root is its own parent.
+     * @type {Uint32Array}
+     */
+    parent: Uint32Array;
+    /**
+     * Head of each vertex's wedge list, or `NULL_POINTER` for a vertex with no corners.
+     * @type {Uint32Array}
+     */
+    first_of_vertex: Uint32Array;
+    /**
+     * Next wedge at the same vertex, or `NULL_POINTER`.
+     * @type {Uint32Array}
+     */
+    next_of_wedge: Uint32Array;
+    /**
+     * How many wedge ids exist, live and merged-away together.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * The root of the wedge `wedge` has been merged into, or itself.
+     *
+     * Path-halving rather than full compression: it is one write per step instead of a second walk,
+     * and it gives the same near-constant amortized bound. This runs once per corner of every
+     * candidate the heap scores, which is several times per edge per round.
+     *
+     * @param {number} wedge
+     * @returns {number}
+     */
+    find(wedge: number): number;
+    /**
+     * Make `other` part of `wedge`.
+     *
+     * Directed on purpose, where a union-find would normally pick the taller tree: the caller is
+     * merging a victim's wedge into a survivor's, and which id survives decides which vertex's list
+     * the result is on. Correctness beats the tree height, and the depth this trades away is what
+     * {@link find}'s path halving pays back.
+     *
+     * @param {number} wedge the root that survives
+     * @param {number} other the root that does not
+     * @returns {boolean} `false` when they were already one wedge and nothing was done
+     */
+    merge(wedge: number, other: number): boolean;
+    /**
+     * Put `wedge` at the head of `vertex`'s list. It must be a root and must not be on any list.
+     *
+     * @param {number} wedge
+     * @param {number} vertex
+     */
+    attach(wedge: number, vertex: number): void;
+    /**
+     * Drop every wedge `vertex` holds, without touching the wedges themselves.
+     *
+     * @param {number} vertex
+     */
+    detach_all(vertex: number): void;
+}
+//# sourceMappingURL=BtWedgeSet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BtWedgeSet.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BtWedgeSet.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACI;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,QAFU,WAAW,CAEO;IAE5B;;;OAGG;IACH,iBAFU,WAAW,CAEgB;IAErC;;;OAGG;IACH,eAFU,WAAW,CAEc;IAEnC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;OASG;IACH,YAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,cAHW,MAAM,UACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;CACJ"}

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

@@ -0,0 +1,128 @@
+import { NULL_POINTER } from "./BinaryTopology.js";
+
+/**
+ * Which corners of a mesh shade as one.
+ *
+ * A **wedge** is a set of loops at one vertex that carry the same appearance. A vertex has one
+ * position and the topology says so; it does not have one *appearance*, and a hard edge or a texture
+ * seam is exactly a vertex whose corners disagree. This is the structure that lets them.
+ *
+ * Three things, and the split between them is the whole design:
+ *
+ * - **{@link of_loop} is never written after construction.** A collapse re-points a victim's loops
+ *   onto the survivor and leaves the loops themselves alone, so a corner's wedge id travels with it
+ *   for free. Nothing has to find a corner in order to move it.
+ * - **{@link parent} is a union-find**, and merging two wedges is a union. That is what makes the
+ *   previous point affordable: the ids a loop holds go stale, {@link find} resolves them, and no
+ *   pass over the loop pool is ever needed to keep them true.
+ * - **{@link first_of_vertex} and {@link next_of_wedge} are one intrusive list per vertex**, which
+ *   is what a collapse iterates. Two typed arrays rather than an array of arrays per vertex: a
+ *   frontier holds every vertex of a level, and on smooth geometry every one of those lists has
+ *   exactly one entry.
+ *
+ * Wedge ids need not be dense and need not agree with vertex ids. {@link bt_wedges_per_vertex}
+ * builds the degenerate set where they are vertex ids — one wedge per vertex, which is a mesh with
+ * no seams and is what every caller that does not care about appearance wants.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BtWedgeSet {
+    /**
+     * The wedge each loop belongs to, indexed by loop id. Read through {@link find}, never trusted
+     * raw: a merge leaves it naming a wedge that is no longer a root.
+     * @type {Uint32Array}
+     */
+    of_loop = new Uint32Array(0);
+
+    /**
+     * Union-find over wedge ids. A root is its own parent.
+     * @type {Uint32Array}
+     */
+    parent = new Uint32Array(0);
+
+    /**
+     * Head of each vertex's wedge list, or `NULL_POINTER` for a vertex with no corners.
+     * @type {Uint32Array}
+     */
+    first_of_vertex = new Uint32Array(0);
+
+    /**
+     * Next wedge at the same vertex, or `NULL_POINTER`.
+     * @type {Uint32Array}
+     */
+    next_of_wedge = new Uint32Array(0);
+
+    /**
+     * How many wedge ids exist, live and merged-away together.
+     * @type {number}
+     */
+    count = 0;
+
+    /**
+     * The root of the wedge `wedge` has been merged into, or itself.
+     *
+     * Path-halving rather than full compression: it is one write per step instead of a second walk,
+     * and it gives the same near-constant amortized bound. This runs once per corner of every
+     * candidate the heap scores, which is several times per edge per round.
+     *
+     * @param {number} wedge
+     * @returns {number}
+     */
+    find(wedge) {
+        const parent = this.parent;
+
+        let root = wedge;
+
+        while (parent[root] !== root) {
+            parent[root] = parent[parent[root]];
+
+            root = parent[root];
+        }
+
+        return root;
+    }
+
+    /**
+     * Make `other` part of `wedge`.
+     *
+     * Directed on purpose, where a union-find would normally pick the taller tree: the caller is
+     * merging a victim's wedge into a survivor's, and which id survives decides which vertex's list
+     * the result is on. Correctness beats the tree height, and the depth this trades away is what
+     * {@link find}'s path halving pays back.
+     *
+     * @param {number} wedge the root that survives
+     * @param {number} other the root that does not
+     * @returns {boolean} `false` when they were already one wedge and nothing was done
+     */
+    merge(wedge, other) {
+        if (wedge === other) {
+            return false;
+        }
+
+        this.parent[other] = wedge;
+
+        return true;
+    }
+
+    /**
+     * Put `wedge` at the head of `vertex`'s list. It must be a root and must not be on any list.
+     *
+     * @param {number} wedge
+     * @param {number} vertex
+     */
+    attach(wedge, vertex) {
+        this.next_of_wedge[wedge] = this.first_of_vertex[vertex];
+
+        this.first_of_vertex[vertex] = wedge;
+    }
+
+    /**
+     * Drop every wedge `vertex` holds, without touching the wedges themselves.
+     *
+     * @param {number} vertex
+     */
+    detach_all(vertex) {
+        this.first_of_vertex[vertex] = NULL_POINTER;
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * One attribute quadric per wedge, accumulated from every allocated triangle.
+ *
+ * The companion of {@link bt_mesh_compute_vertex_quadrics}, and deliberately its *companion* rather
+ * than an extension of it: that one stays the pure geometric quadric, which is what lets the error a
+ * caller reports stay an object-space length no matter what this one does to the placement
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §3). Solve in the higher-dimensional metric, evaluate in the 3-D one.
+ *
+ * The attribute values arrive as a flat array indexed by **wedge** id — `components` scalars each,
+ * whatever they happen to mean. This pass does not know and does not need to: a channel is a number
+ * per corner that varies affinely over a triangle, and a normal, a texture coordinate and a colour
+ * are all that.
+ *
+ * Per wedge rather than per vertex because a vertex has one position and not one appearance, and per
+ * wedge rather than per *corner* because a single corner's quadric would only ever hold its own
+ * triangle — a field fitted from one triangle is exact and says nothing. The history is what a
+ * quadric is for, and the history belongs to the set of corners that share a value.
+ * {@link bt_wedges_per_vertex} is the set for a mesh with no seams, where a wedge id *is* a vertex
+ * id and this is per vertex again.
+ *
+ * Non-triangular faces are skipped, as they are in the geometric pass. So are slivers, by
+ * {@link quadric_attribute_set_from_triangle}'s own test — a gradient that divides by twice the area
+ * would otherwise outweigh every honest triangle around it.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} values `wedges.count * components` scalars, indexed by wedge id
+ * @param {number} components number of scalar channels
+ * @param {ArrayLike<number>} weights one per channel, mapping it into units of length
+ * @param {BtWedgeSet} wedges which corners of each vertex shade as one
+ * @returns {Float64Array} `wedges.count * quadric_attribute_size(components)` elements, indexed by
+ *     wedge id; a slot no triangle used holds a quadric of zero weight, which
+ *     {@link quadric_attribute_solve} refuses rather than answering from
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_compute_wedge_attribute_quadrics(mesh: BinaryTopology, values: ArrayLike<number>, components: number, weights: ArrayLike<number>, wedges: BtWedgeSet): Float64Array;
+//# sourceMappingURL=bt_mesh_compute_wedge_attribute_quadrics.d.ts.map

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

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

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

@@ -0,0 +1,113 @@
+import { assert } from "../../../../../../assert.js";
+import {
+    quadric_attribute_add
+} from "../../../../quadric/quadric_attribute_add.js";
+import {
+    quadric_attribute_set_from_triangle
+} from "../../../../quadric/quadric_attribute_set_from_triangle.js";
+import { quadric_attribute_size } from "../../../../quadric/quadric_attribute_size.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * One triangle's contribution, before it is accumulated onto each of its corners.
+ * @type {Float64Array}
+ */
+let scratch_quadric = new Float64Array(0);
+
+/**
+ * One attribute quadric per wedge, accumulated from every allocated triangle.
+ *
+ * The companion of {@link bt_mesh_compute_vertex_quadrics}, and deliberately its *companion* rather
+ * than an extension of it: that one stays the pure geometric quadric, which is what lets the error a
+ * caller reports stay an object-space length no matter what this one does to the placement
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §3). Solve in the higher-dimensional metric, evaluate in the 3-D one.
+ *
+ * The attribute values arrive as a flat array indexed by **wedge** id — `components` scalars each,
+ * whatever they happen to mean. This pass does not know and does not need to: a channel is a number
+ * per corner that varies affinely over a triangle, and a normal, a texture coordinate and a colour
+ * are all that.
+ *
+ * Per wedge rather than per vertex because a vertex has one position and not one appearance, and per
+ * wedge rather than per *corner* because a single corner's quadric would only ever hold its own
+ * triangle — a field fitted from one triangle is exact and says nothing. The history is what a
+ * quadric is for, and the history belongs to the set of corners that share a value.
+ * {@link bt_wedges_per_vertex} is the set for a mesh with no seams, where a wedge id *is* a vertex
+ * id and this is per vertex again.
+ *
+ * Non-triangular faces are skipped, as they are in the geometric pass. So are slivers, by
+ * {@link quadric_attribute_set_from_triangle}'s own test — a gradient that divides by twice the area
+ * would otherwise outweigh every honest triangle around it.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} values `wedges.count * components` scalars, indexed by wedge id
+ * @param {number} components number of scalar channels
+ * @param {ArrayLike<number>} weights one per channel, mapping it into units of length
+ * @param {BtWedgeSet} wedges which corners of each vertex shade as one
+ * @returns {Float64Array} `wedges.count * quadric_attribute_size(components)` elements, indexed by
+ *     wedge id; a slot no triangle used holds a quadric of zero weight, which
+ *     {@link quadric_attribute_solve} refuses rather than answering from
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_compute_wedge_attribute_quadrics(mesh, values, components, weights, wedges) {
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+    assert.isPositiveInteger(components, 'components');
+
+    const size = quadric_attribute_size(components);
+
+    if (scratch_quadric.length < size) {
+        scratch_quadric = new Float64Array(size);
+    }
+
+    const result = new Float64Array(wedges.count * size);
+
+    const face_pool = mesh.faces;
+
+    const coordinate = new Float32Array(9);
+
+    for (let face = 0; face < face_pool.size; face++) {
+        if (!face_pool.is_allocated(face)) {
+            continue;
+        }
+
+        const la = mesh.face_read_loop(face);
+
+        if (la === NULL_POINTER) {
+            continue;
+        }
+
+        const lb = mesh.loop_read_next(la);
+        const lc = mesh.loop_read_next(lb);
+
+        if (mesh.loop_read_next(lc) !== la) {
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(coordinate, 0, mesh.loop_read_vertex(la));
+        mesh.vertex_read_coordinate(coordinate, 3, mesh.loop_read_vertex(lb));
+        mesh.vertex_read_coordinate(coordinate, 6, mesh.loop_read_vertex(lc));
+
+        const wa = wedges.find(wedges.of_loop[la]);
+        const wb = wedges.find(wedges.of_loop[lb]);
+        const wc = wedges.find(wedges.of_loop[lc]);
+
+        const built = quadric_attribute_set_from_triangle(
+            scratch_quadric, 0, components, weights,
+            coordinate[0], coordinate[1], coordinate[2],
+            coordinate[3], coordinate[4], coordinate[5],
+            coordinate[6], coordinate[7], coordinate[8],
+            values, wa * components, wb * components, wc * components
+        );
+
+        if (!built) {
+            continue;
+        }
+
+        quadric_attribute_add(result, wa * size, result, wa * size, scratch_quadric, 0, components);
+        quadric_attribute_add(result, wb * size, result, wb * size, scratch_quadric, 0, components);
+        quadric_attribute_add(result, wc * size, result, wc * size, scratch_quadric, 0, components);
+    }
+
+    return result;
+}

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

@@ -71,9 +71,55 @@ export function bt_mesh_simplify(mesh: BinaryTopology, target_face_count: number
  * @param {number} target_face_count Desired face count after simplification.
  * @param {Set<number>} restricted_vertices Vertices that must not move or be removed.
  * @param {Set<number>} protected_faces Faces that must not be removed.
+ * `attributes` is per-vertex data that travels *through* the collapse rather than being re-derived
+ * from the result. Whatever a merged vertex is to carry has to be decided here, from the values
+ * being merged: the mesh a collapse leaves behind is a different surface, and a value read off it
+ * afterwards describes that one rather than the one the caller started with.
+ *
+ * It is carried per **wedge** — a set of corners at one vertex that shade as one — so a hard edge
+ * or a texture seam survives a collapse instead of being averaged away. Which of the pair's wedges
+ * become one is decided by the faces the collapse destroys, in {@link reduce_pair_attributes}; a
+ * mesh with no seams has one wedge per vertex, every collapse merges the pair, and all of this is
+ * the arithmetic it always was.
+ *
+ * It is **fitted**, not inherited and not averaged. Each channel varies affinely over a triangle, so
+ * every triangle a wedge has ever absorbed says what that channel should be at any position; the
+ * survivor takes the value that best explains all of them at once, at the position it is being moved
+ * to ({@link quadric_attribute_solve}). Those same accumulated fields also reach the *placement* and
+ * the cost, through {@link quadric_attribute_reduce} -- so a collapse that would smear a crease or a
+ * texture seam is both moved away from it and priced for it. A vertex with no field to fit from
+ * falls back to a weighted blend, and a **restricted** survivor is left exactly as it is, for the
+ * same reason its position is.
+ *
+ * The values themselves mean nothing here. A caller whose record holds a direction or a flag rather
+ * than a quantity has to say so afterwards, over the array this leaves behind.
+ *
+ * What the call **returns** is still the pure geometric quadric's answer, evaluated at wherever the
+ * higher-dimensional metric put each vertex. Solving in one metric and reporting in the other is
+ * what keeps the number an object-space length (`VIRTUAL_GEOMETRY_DESIGN.md` §3).
+ *
  * @param {Quadric3[]} quadratics indexed by vertex id, one per allocated vertex; mutated in place
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} [attributes]
+ *     per-wedge records to carry through the collapses, with the attribute quadrics that fit them
+ *     ({@link bt_mesh_compute_wedge_attribute_quadrics}) and the per-channel weights those were
+ *     built with. `values` and `quadrics` are indexed by **wedge id**;
+ *     {@link bt_wedges_per_vertex} is the set where that is the vertex id. `null` to carry nothing,
+ *     which is what every caller but the virtual-geometry builder does. {@link bt_mesh_simplify_by_error}
+ *     is not among them at all — it is a separate implementation with its own cost function, and so
+ *     is untouched by any of this, which matters because it simplifies to a *tolerance* that an
+ *     attribute term would quietly move.
+ * @param {BtWedgeSet|null} [wedges] which corners of each vertex shade as one, **mutated in place**
+ *     as the collapses merge them. Required when `attributes` is given, and useful without it: a
+ *     caller that carries no values may still care which corners of the result belong together, and
+ *     a set that is not maintained is a set whose ids go stale — corners of one vertex would resolve
+ *     to different wedges and every consumer downstream would see a seam that is not there.
  * @returns {number} object-space distance the surface moved, `0` when no collapse was performed
  */
-export function bt_mesh_simplify_with_quadrics(mesh: BinaryTopology, target_face_count: number, restricted_vertices: Set<number>, protected_faces: Set<number>, quadratics: Quadric3[]): number;
+export function bt_mesh_simplify_with_quadrics(mesh: BinaryTopology, target_face_count: number, restricted_vertices: Set<number>, protected_faces: Set<number>, quadratics: Quadric3[], attributes?: {
+    values: Float64Array;
+    components: number;
+    quadrics: Float64Array;
+    weights: Float64Array;
+} | null, wedges?: BtWedgeSet | null): number;
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
 //# sourceMappingURL=bt_mesh_simplify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AA8NA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,0EALW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAwBlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wFANW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cACX,QAAQ,EAAE,GACR,MAAM,CAqJlB;yBAldwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AA4yBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,0EALW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAwBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wFA/CW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cA4BX,QAAQ,EAAE,eACV;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GAAC,IAAI,WAS9F,aAAW,IAAI,GAKb,MAAM,CA2LlB;yBA/mCwB,iCAAiC"}