@woosh/meep-engine 3.27.0 → 3.29.0

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js

@@ -0,0 +1,371 @@
+import { aabb3_from_v3_array } from "../../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { v3_morton_encode_bounded } from "../../../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
+import {
+    bt_face_read_triangle_vertices
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+import { vgeo_split_face_set } from "./vgeo_split_face_set.js";
+
+/**
+ * {@link vgeo_split_face_set}, then merge the under-filled pieces it left behind.
+ *
+ * Only its callers want this: under-filled pieces are merged back together along a Morton curve, so
+ * that a set made of islands does not come back as one cluster per island. That is what a group's
+ * re-split needs — without it a group of loose bolts simplifies and then splits straight back into
+ * as many clusters as it started with, and the DAG never converges. It is emphatically *not* what
+ * the leaf cut wants: the leaf cut runs over the whole mesh, where "nearest on the curve" can be
+ * sixty metres away, and a leaf cluster spanning that carries a bounding sphere to match. A group
+ * has already been chosen for proximity, so packing inside one cannot reach further than the group
+ * does.
+ *
+ * The merge is two passes, and the caps decide which one is used rather than taste. The first walks
+ * the curve, so every cluster it makes is a run of it holding pieces that were beside each other —
+ * and over a real asset that is almost always all it takes: across a build of the Zorah sample it
+ * lands on the fewest clusters both caps allow in 97.6% of the re-cuts. The second pass is for the
+ * rest. Where the curve costs a whole extra cluster, the pieces are offered again largest first,
+ * into whichever cluster still has room. Reaching past a neighbour widens what a cluster carries, so
+ * it has to buy something; one cluster fewer is the price at which it does.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+const scratch_triangle = new Uint32Array(3);
+const scratch_coordinate = new Float32Array(3);
+
+/**
+ * The **wedges** a set of dense face-graph vertices touches, deduplicated.
+ *
+ * Wedges and not mesh vertices, because a bin is a meshlet and a meshlet carries one record per
+ * wedge — see {@link VGeoFaceGraph#count_unique_wedges}, which is the same question asked of a
+ * whole part rather than of a piece being packed into one. The set is kept rather than counted here
+ * because the packer needs to know how much two pieces *overlap*, not only how big each is.
+ *
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members
+ * @returns {Set<number>}
+ */
+function unique_wedges(face_graph, members) {
+    const result = new Set();
+
+    const mesh = face_graph.mesh;
+    const wedges = face_graph.wedges;
+
+    for (const member of members) {
+        let loop = mesh.face_read_loop(face_graph.vertex_face_ids[member]);
+
+        for (let corner = 0; corner < 3; corner++) {
+            result.add(wedges.find(wedges.of_loop[loop]));
+
+            loop = mesh.loop_read_next(loop);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Mean position of every corner of every face in a piece.
+ *
+ * @param {Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members
+ */
+function piece_centroid(result, result_offset, face_graph, members) {
+    const mesh = face_graph.mesh;
+
+    let x = 0;
+    let y = 0;
+    let z = 0;
+
+    const vertex_face_ids = face_graph.vertex_face_ids;
+
+    for (const member of members) {
+        bt_face_read_triangle_vertices(scratch_triangle, mesh, vertex_face_ids[member]);
+
+        for (let i = 0; i < 3; i++) {
+            mesh.vertex_read_coordinate(scratch_coordinate, 0, scratch_triangle[i]);
+
+            x += scratch_coordinate[0];
+            y += scratch_coordinate[1];
+            z += scratch_coordinate[2];
+        }
+    }
+
+    const corner_count = members.length * 3;
+
+    result[result_offset] = x / corner_count;
+    result[result_offset + 1] = y / corner_count;
+    result[result_offset + 2] = z / corner_count;
+}
+
+/**
+ * The pieces in Morton order of their centroids, so that neighbours in it were neighbours in space.
+ *
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[][]} pieces
+ * @returns {number[]} indices into `pieces`
+ */
+function curve_order(face_graph, pieces) {
+    const centroids = new Float32Array(pieces.length * 3);
+
+    pieces.forEach((piece, index) => piece_centroid(centroids, index * 3, face_graph, piece));
+
+    const bounds = new Float32Array(6);
+
+    aabb3_from_v3_array(bounds, centroids, centroids.length);
+
+    const codes = pieces.map(
+        (piece, index) => v3_morton_encode_bounded(
+            centroids[index * 3],
+            centroids[index * 3 + 1],
+            centroids[index * 3 + 2],
+            bounds
+        )
+    );
+
+    const order = pieces.map((piece, index) => index);
+
+    order.sort((a, b) => (codes[a] - codes[b]) || (pieces[a][0] - pieces[b][0]));
+
+    return order;
+}
+
+/**
+ * A cluster under construction: which pieces are in it, and both of the numbers it is capped on.
+ *
+ * @param {number} index of the piece it starts from
+ * @param {number[]} piece
+ * @param {Set<number>} vertices the piece touches
+ * @returns {{pieces: number[], faces: number, vertices: Set<number>}}
+ */
+function open_bin(index, piece, vertices) {
+    return { pieces: [index], faces: piece.length, vertices: new Set(vertices) };
+}
+
+/**
+ * Whether a piece can go into a bin without breaking either cap.
+ *
+ * The vertex side is a union rather than a sum: two pieces cut out of the same component share the
+ * vertices along the cut, and charging for those twice would refuse a merge that fits.
+ *
+ * @param {{faces: number, vertices: Set<number>}} bin
+ * @param {number[]} piece
+ * @param {Set<number>} vertices the piece touches
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {boolean}
+ */
+function bin_accepts(bin, piece, vertices, max_faces, max_vertices) {
+    if (bin.faces + piece.length > max_faces) {
+        return false;
+    }
+
+    let added = 0;
+
+    for (const vertex of vertices) {
+        if (!bin.vertices.has(vertex)) {
+            added++;
+        }
+    }
+
+    return bin.vertices.size + added <= max_vertices;
+}
+
+/**
+ * @param {{pieces: number[], faces: number, vertices: Set<number>}} bin
+ * @param {number} index of the piece
+ * @param {number[]} piece
+ * @param {Set<number>} vertices the piece touches
+ */
+function bin_add(bin, index, piece, vertices) {
+    bin.pieces.push(index);
+    bin.faces += piece.length;
+
+    for (const vertex of vertices) {
+        bin.vertices.add(vertex);
+    }
+}
+
+/**
+ * Walk the curve, opening a new cluster whenever the next piece does not fit in the one already
+ * open.
+ *
+ * Next-fit rather than best-fit: the curve already put spatial neighbours side by side, and letting a
+ * piece jump backwards to top up an earlier bin would pull distant geometry into it for the sake of
+ * a few triangles of fill. Every cluster this produces is a contiguous run of the curve.
+ *
+ * @param {number[][]} pieces
+ * @param {Set<number>[]} piece_vertices one entry per piece
+ * @param {number[]} order indices into `pieces`, along the curve
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {{pieces: number[], faces: number, vertices: Set<number>}[]}
+ */
+function fill_along_curve(pieces, piece_vertices, order, max_faces, max_vertices) {
+    const result = [];
+
+    for (const index of order) {
+        const bin = result[result.length - 1];
+
+        if (
+            bin !== undefined
+            && bin_accepts(bin, pieces[index], piece_vertices[index], max_faces, max_vertices)
+        ) {
+            bin_add(bin, index, pieces[index], piece_vertices[index]);
+
+            continue;
+        }
+
+        result.push(open_bin(index, pieces[index], piece_vertices[index]));
+    }
+
+    return result;
+}
+
+/**
+ * Offer the pieces largest first, each into the first cluster that will take it.
+ *
+ * Largest first is the whole of the difference, and for the usual reason: a cluster already topped up
+ * with small pieces has no room left for a big one, so the big ones have to choose first. Two 66s and
+ * a 40 and a 34 are two clusters when the 66s choose first and three when they do not, and no walk of
+ * the curve finds the pairing because the pieces that belong together are not neighbours on it.
+ *
+ * The clusters are still tried in the curve's order, so a piece lands in the earliest — nearest —
+ * one that can hold it.
+ *
+ * @param {number[][]} pieces
+ * @param {Set<number>[]} piece_vertices one entry per piece
+ * @param {number[]} order indices into `pieces`, along the curve
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {{pieces: number[], faces: number, vertices: Set<number>}[]}
+ */
+function fill_largest_first(pieces, piece_vertices, order, max_faces, max_vertices) {
+    /**
+     * `piece -> its place on the curve`, so that pieces of the same size keep the curve's order and
+     * the pack stays a function of the geometry rather than of the sort's own tie-breaking.
+     * @type {Int32Array}
+     */
+    const place = new Int32Array(pieces.length);
+
+    order.forEach((index, position) => {
+        place[index] = position;
+    });
+
+    // How much of a cluster a piece costs, on whichever of the two caps it loads most.
+    const load = (index) => Math.max(
+        pieces[index].length / max_faces, piece_vertices[index].size / max_vertices
+    );
+
+    const by_size = order.slice();
+
+    by_size.sort((a, b) => (load(b) - load(a)) || (place[a] - place[b]));
+
+    const result = [];
+
+    for (const index of by_size) {
+        let placed = false;
+
+        for (const bin of result) {
+            if (!bin_accepts(bin, pieces[index], piece_vertices[index], max_faces, max_vertices)) {
+                continue;
+            }
+
+            bin_add(bin, index, pieces[index], piece_vertices[index]);
+
+            placed = true;
+
+            break;
+        }
+
+        if (!placed) {
+            result.push(open_bin(index, pieces[index], piece_vertices[index]));
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Merge under-filled pieces into shared clusters.
+ *
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[][]} pieces each already within both caps
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @param {number} floor fewest clusters both caps allow for the set as a whole
+ * @returns {number[][]}
+ */
+function pack_pieces(face_graph, pieces, max_faces, max_vertices, floor) {
+
+    if (pieces.length < 2) {
+        // nothing to merge, pass through
+        return pieces;
+    }
+
+    const piece_vertices = pieces.map((piece) => unique_wedges(face_graph, piece));
+
+    const order = curve_order(face_graph, pieces);
+
+    let bins = fill_along_curve(pieces, piece_vertices, order, max_faces, max_vertices);
+
+    if (bins.length > floor) {
+        // The caps would have held this in fewer clusters and walking the curve did not find how.
+        // Nothing local says which pieces belong together, so the only way to learn whether the
+        // extra cluster was necessary is to pack again with size deciding instead of position, and
+        // to keep that only if it turns out it was not.
+        const by_size = fill_largest_first(pieces, piece_vertices, order, max_faces, max_vertices);
+
+        if (by_size.length < bins.length) {
+            bins = by_size;
+        }
+    }
+
+    return bins.map((bin) => {
+        const packed = [];
+
+        for (const index of bin.pieces) {
+            for (const member of pieces[index]) {
+                packed.push(member);
+            }
+        }
+
+        packed.sort((a, b) => a - b);
+
+        return packed;
+    });
+}
+
+/**
+ * Split a face set into clusters within both meshlet caps, then merge the under-filled pieces.
+ *
+ * Only for sets whose spatial extent something else has already bounded — a group being re-split
+ * after simplification. Over an unbounded set this packs together whatever the Morton curve happens
+ * to place side by side, which is not the same question as "what is near what".
+ *
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members dense face-graph vertices to split
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {number[][]} clusters within both caps, ordered by their lowest member
+ */
+export function vgeo_split_face_set_packed(face_graph, members, max_faces, max_vertices) {
+    // What a perfect packing of this set would come back with. It is a bound and not always a
+    // reachable one — indivisible pieces need not add up to it — but it is the only thing that says
+    // whether the merge left a cluster on the table, and so the only thing that can decide whether
+    // the merge is worth attempting a second way.
+    const floor = Math.max(
+        Math.ceil(members.length / max_faces),
+        Math.ceil(face_graph.count_unique_wedges(members) / max_vertices)
+    );
+
+    const packed = pack_pieces(
+        face_graph, vgeo_split_face_set(face_graph, members, max_faces, max_vertices),
+        max_faces, max_vertices, floor
+    );
+
+    packed.sort((a, b) => a[0] - b[0]);
+
+    return packed;
+}

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_bounding_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_bounding_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_bounding_sphere.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,6CANW,YAAY,GACV,YAAY,CAiBxB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_bounding_sphere.js → sphere/vgeo_bounding_sphere.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
+import { assert } from "../../../../../../core/assert.js";
+import { Miniball } from "../../../../../../core/geom/packing/miniball/Miniball.js";
+import { PointSet } from "../../../../../../core/geom/packing/miniball/PointSet.js";
 import { vgeo_sphere_inflate_to_contain } from "./vgeo_sphere_inflate_to_contain.js";
 
 /**

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_containing_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_containing_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_containing_sphere.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,gDAPW,UAAU,MAAM,CAAC,EAAE,UACnB,YAAY,GACV,YAAY,CA2BxB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_containing_sphere.js → sphere/vgeo_containing_sphere.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
+import { assert } from "../../../../../../core/assert.js";
+import { Miniball } from "../../../../../../core/geom/packing/miniball/Miniball.js";
+import { PointSet } from "../../../../../../core/geom/packing/miniball/PointSet.js";
 import { vgeo_sphere_inflate_to_contain } from "./vgeo_sphere_inflate_to_contain.js";
 
 /**

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_sphere_inflate_to_contain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_sphere_inflate_to_contain.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_sphere_inflate_to_contain.js"],"names":[],"mappings":"AA0CA;;;;;;GAMG;AACH,uDAJW,YAAY,UACZ,YAAY,WACZ,UAAU,MAAM,CAAC,EAAE,QAsB7B"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_sphere_inflate_to_contain.js → sphere/vgeo_sphere_inflate_to_contain.js}

@@ -1,4 +1,4 @@
-import { f32_next_up } from "../../../../../core/math/f32_next_up.js";
+import { f32_next_up } from "../../../../../../core/math/f32_next_up.js";
 
 /**
  * Bounds that still bound after they have been rounded to float32.

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A face set gathered into standalone, locally-indexed form.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoGatheredFaces {
+    /**
+     * `3 * vertex_count` local coordinates.
+     * @type {Float32Array}
+     */
+    positions: Float32Array;
+    /**
+     * `3 * triangle_count` local vertex indices.
+     * @type {Uint32Array}
+     */
+    indices: Uint32Array;
+    /**
+     * Vertex ids in the mesh this was pulled out of, one per local vertex, in first-use order.
+     *
+     * **Not unique.** One entry per *wedge*, so a vertex whose corners shade two ways appears twice
+     * — which is what a seam has always cost, in any renderer, and is where it is paid.
+     * @type {Uint32Array}
+     */
+    vertex_ids: Uint32Array;
+    /**
+     * The wedge each local vertex is, named in the mesh this was pulled out of. Parallel to
+     * {@link vertex_ids}, and unique where that is not.
+     * @type {Uint32Array}
+     */
+    wedge_ids: Uint32Array;
+    /**
+     * One corner per output vertex — the loop it was first seen at — for the appearance channels to
+     * be read through. They live on corners, so a vertex alone does not address them.
+     * @type {Uint32Array}
+     */
+    attribute_ids: Uint32Array;
+}
+//# sourceMappingURL=VGeoGatheredFaces.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoGatheredFaces.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;OAGG;IACH,WAFU,YAAY,CAEU;IAEhC;;;OAGG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;;;OAMG;IACH,YAFU,WAAW,CAEW;IAEhC;;;;OAIG;IACH,WAFU,WAAW,CAEU;IAE/B;;;;OAIG;IACH,eAFU,WAAW,CAEc;CACtC"}

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.js

@@ -0,0 +1,42 @@
+/**
+ * A face set gathered into standalone, locally-indexed form.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoGatheredFaces {
+    /**
+     * `3 * vertex_count` local coordinates.
+     * @type {Float32Array}
+     */
+    positions = new Float32Array(0);
+
+    /**
+     * `3 * triangle_count` local vertex indices.
+     * @type {Uint32Array}
+     */
+    indices = new Uint32Array(0);
+
+    /**
+     * Vertex ids in the mesh this was pulled out of, one per local vertex, in first-use order.
+     *
+     * **Not unique.** One entry per *wedge*, so a vertex whose corners shade two ways appears twice
+     * — which is what a seam has always cost, in any renderer, and is where it is paid.
+     * @type {Uint32Array}
+     */
+    vertex_ids = new Uint32Array(0);
+
+    /**
+     * The wedge each local vertex is, named in the mesh this was pulled out of. Parallel to
+     * {@link vertex_ids}, and unique where that is not.
+     * @type {Uint32Array}
+     */
+    wedge_ids = new Uint32Array(0);
+
+    /**
+     * One corner per output vertex — the loop it was first seen at — for the appearance channels to
+     * be read through. They live on corners, so a vertex alone does not address them.
+     * @type {Uint32Array}
+     */
+    attribute_ids = new Uint32Array(0);
+}

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A face set pulled out of a larger mesh, with the map back to where it came from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoSubmesh {
+    /**
+     * @type {VirtualGeometryMesh}
+     */
+    mesh: VirtualGeometryMesh;
+    /**
+     * `source_vertex_ids[local] = vertex id in the mesh this was extracted from`. Survives
+     * simplification: the simplifier never creates a vertex, and a pinned one is never moved, so a
+     * vertex two submeshes share still answers to the same source id in both.
+     * @type {Uint32Array}
+     */
+    source_vertex_ids: Uint32Array;
+    /**
+     * Which corners of {@link mesh} shade as one, in ids local to it. Mutated by the simplifier as
+     * they merge, which is why a local id is what the carried values and quadrics are indexed by.
+     * @type {BtWedgeSet}
+     */
+    wedges: BtWedgeSet;
+    /**
+     * `source_wedge_ids[local wedge] = wedge id in the mesh this was extracted from`, the companion
+     * of {@link source_vertex_ids} and what carries an accumulated attribute quadric across the
+     * seam.
+     *
+     * Survives simplification the way the vertex map does, and for a sharper reason: **a collapse
+     * only ever merges wedges, never splits one**, so a local id that is still its own root after a
+     * step names exactly the source wedge it always did.
+     * @type {Uint32Array}
+     */
+    source_wedge_ids: Uint32Array;
+}
+//# sourceMappingURL=VGeoSubmesh.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoSubmesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;OAEG;IACH,0BAAY;IAEZ;;;;;OAKG;IACH,mBAFU,WAAW,CAEkB;IAEvC;;;;OAIG;IACH,mBAAc;IAEd;;;;;;;;;OASG;IACH,kBAFU,WAAW,CAEiB;CACzC"}

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.js

@@ -0,0 +1,39 @@
+/**
+ * A face set pulled out of a larger mesh, with the map back to where it came from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoSubmesh {
+    /**
+     * @type {VirtualGeometryMesh}
+     */
+    mesh = null;
+
+    /**
+     * `source_vertex_ids[local] = vertex id in the mesh this was extracted from`. Survives
+     * simplification: the simplifier never creates a vertex, and a pinned one is never moved, so a
+     * vertex two submeshes share still answers to the same source id in both.
+     * @type {Uint32Array}
+     */
+    source_vertex_ids = new Uint32Array(0);
+
+    /**
+     * Which corners of {@link mesh} shade as one, in ids local to it. Mutated by the simplifier as
+     * they merge, which is why a local id is what the carried values and quadrics are indexed by.
+     * @type {BtWedgeSet}
+     */
+    wedges = null;
+
+    /**
+     * `source_wedge_ids[local wedge] = wedge id in the mesh this was extracted from`, the companion
+     * of {@link source_vertex_ids} and what carries an accumulated attribute quadric across the
+     * seam.
+     *
+     * Survives simplification the way the vertex map does, and for a sharper reason: **a collapse
+     * only ever merges wedges, never splits one**, so a local id that is still its own root after a
+     * step names exactly the source wedge it always did.
+     * @type {Uint32Array}
+     */
+    source_wedge_ids = new Uint32Array(0);
+}

package/src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extract a face set into a standalone mesh, attributes and all.
+ *
+ * **Wedges are not vertices here.** The gather deduped on the wedge, because that is what a cluster
+ * payload's vertices are; a mesh's are not. Two wedges of one vertex are one point and one piece of
+ * connectivity, and giving them a vertex each would shred face adjacency along every seam — which
+ * is the move `WEDGE_PLAN_2026_09_18.md` §8 rejects and the reason the weld exists at all. So the
+ * gather's output is folded back onto one vertex per position and the wedges travel on the corners,
+ * where they belong.
+ *
+ * @param {VirtualGeometryMesh} source
+ * @param {number[]} face_ids
+ * @param {BtWedgeSet} source_wedges which corners of `source` shade as one
+ * @returns {VGeoSubmesh}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_extract_submesh(source: VirtualGeometryMesh, face_ids: number[], source_wedges: BtWedgeSet): VGeoSubmesh;
+import { VirtualGeometryMesh } from "../mesh/VirtualGeometryMesh.js";
+import { BtWedgeSet } from "../../../../../../core/geom/3d/topology/struct/binary/BtWedgeSet.js";
+import { VGeoSubmesh } from "./VGeoSubmesh.js";
+//# sourceMappingURL=vgeo_extract_submesh.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_extract_submesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,6CARW,mBAAmB,YACnB,MAAM,EAAE,iBACR,UAAU,GACR,WAAW,CA4GvB;oCA3HmC,gCAAgC;2BARzC,qEAAqE;4BAOpE,kBAAkB"}