@woosh/meep-engine 3.26.0 → 3.28.0

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Partition a graph, and keep the build alive if the partitioner cannot.
+ *
+ * METIS is what should do this and what does do it: better cuts, and every partition the builder has
+ * ever produced has come from it. What it does not promise is to succeed. A build is an offline tool
+ * run over whatever a scanner or a CAD exporter produced, and a partitioner that throws takes the
+ * whole asset with it — for input nobody can inspect and a failure nobody can act on. The spectral
+ * bisection underneath is worse at its job and always finishes, which for a fallback is the right
+ * way round.
+ *
+ * This is not error suppression. A partitioner declining a graph is an expected outcome for input
+ * this open-ended, and the response is to use the other one — the same shape as a group that will
+ * not simplify going back to the frontier rather than failing its round. What is *not* caught is
+ * both of them failing: that is a bug, and it is thrown with both causes named.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {number} vertex_count
+ * @param {number} partition_count
+ * @param {Uint32Array} edge_addresses CSR row pointers, length `vertex_count + 1`
+ * @param {Uint32Array} adjacency CSR column indices
+ * @param {Float32Array} edge_weights parallel to `adjacency`
+ * @param {number} seed for METIS, so the same graph partitions the same way
+ * @returns {Uint32Array} partition assignment per vertex, values in `[0, partition_count)`
+ */
+export function vgeo_partition_graph(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array, seed: number): Uint32Array;
+//# sourceMappingURL=vgeo_partition_graph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_partition_graph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;GAQG;AACH,mDARW,MAAM,mBACN,MAAM,kBACN,WAAW,aACX,WAAW,gBACX,YAAY,QACZ,MAAM,GACJ,WAAW,CA0BvB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_partition_graph.js → partition/vgeo_partition_graph.js}

@@ -1,5 +1,5 @@
-import { graph_partition_spectral } from "../../../../../core/graph/graph_partition_spectral.js";
-import { metis_partition_kway } from "../../../../../core/graph/metis/native/metis_partition_kway.js";
+import { graph_partition_spectral } from "../../../../../../core/graph/graph_partition_spectral.js";
+import { metis_partition_kway } from "../../../../../../core/graph/metis/native/metis_partition_kway.js";
 
 /**
  * Partition a graph, and keep the build alive if the partitioner cannot.

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Partition the subgraph a CSR induces on a member set.
+ *
+ * Both places the builder partitions something want this, and for the same reason the components
+ * pass beside it exists: METIS takes a graph, not a graph and a mask, so the members have to be
+ * renumbered into a dense local graph first and the assignment scattered back afterwards. That is
+ * forty lines of the same bookkeeping either side of one call, and it was written twice — once for
+ * splitting faces into clusters, once for grouping clusters into groups.
+ *
+ * The two copies had already drifted on the point one of them documents at length: the face side
+ * keeps a dense `Uint32Array` scratch because a `Map` cannot answer this at all past 2^24 entries
+ * and the leaf cut runs over every face of the mesh at once, while the cluster side had reached for
+ * a `Map`. Taking the scratch as a parameter is what makes that a property of this function rather
+ * than of whoever last copied it.
+ *
+ * Edge weights are carried through unchanged; a caller that wants them shaped — the group pass
+ * scales by compactness — does that when it builds the CSR.
+ *
+ * @param {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}} graph
+ *     CSR over the whole vertex set
+ * @param {number[]} members vertices of the subgraph to partition
+ * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a
+ *     member, which is what keeps a nested split from following an edge that leaves its subset
+ * @param {number} token
+ * @param {number} part_count at least 2
+ * @param {number} seed fixed by the caller, so the same subgraph always splits the same way
+ * @param {Uint32Array} local_index scratch, one entry per graph vertex. Only the members' entries
+ *     are written or read, so it never needs clearing between calls
+ * @returns {number[][]} the non-empty parts, in part order. **May be a single part** — METIS
+ *     balances what it is asked for but is not obliged to fill every bin, and a caller that needs
+ *     to make progress has to say what it does about that
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_partition_subgraph(graph: {
+    edge_addresses: Uint32Array;
+    adjacency: Uint32Array;
+    edge_weights: Float32Array;
+}, members: number[], membership: Int32Array, token: number, part_count: number, seed: number, local_index: Uint32Array): number[][];
+//# sourceMappingURL=vgeo_partition_subgraph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_partition_subgraph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,+CAjBW;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC,WAEjF,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,cACN,MAAM,QACN,MAAM,eACN,WAAW,GAET,MAAM,EAAE,EAAE,CA4DtB"}

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

@@ -0,0 +1,92 @@
+import { assert } from "../../../../../../core/assert.js";
+import { vgeo_partition_graph } from "./vgeo_partition_graph.js";
+
+/**
+ * Partition the subgraph a CSR induces on a member set.
+ *
+ * Both places the builder partitions something want this, and for the same reason the components
+ * pass beside it exists: METIS takes a graph, not a graph and a mask, so the members have to be
+ * renumbered into a dense local graph first and the assignment scattered back afterwards. That is
+ * forty lines of the same bookkeeping either side of one call, and it was written twice — once for
+ * splitting faces into clusters, once for grouping clusters into groups.
+ *
+ * The two copies had already drifted on the point one of them documents at length: the face side
+ * keeps a dense `Uint32Array` scratch because a `Map` cannot answer this at all past 2^24 entries
+ * and the leaf cut runs over every face of the mesh at once, while the cluster side had reached for
+ * a `Map`. Taking the scratch as a parameter is what makes that a property of this function rather
+ * than of whoever last copied it.
+ *
+ * Edge weights are carried through unchanged; a caller that wants them shaped — the group pass
+ * scales by compactness — does that when it builds the CSR.
+ *
+ * @param {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}} graph
+ *     CSR over the whole vertex set
+ * @param {number[]} members vertices of the subgraph to partition
+ * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a
+ *     member, which is what keeps a nested split from following an edge that leaves its subset
+ * @param {number} token
+ * @param {number} part_count at least 2
+ * @param {number} seed fixed by the caller, so the same subgraph always splits the same way
+ * @param {Uint32Array} local_index scratch, one entry per graph vertex. Only the members' entries
+ *     are written or read, so it never needs clearing between calls
+ * @returns {number[][]} the non-empty parts, in part order. **May be a single part** — METIS
+ *     balances what it is asked for but is not obliged to fill every bin, and a caller that needs
+ *     to make progress has to say what it does about that
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_partition_subgraph(
+    graph, members, membership, token, part_count, seed, local_index
+) {
+    assert.greaterThanOrEqual(part_count, 2, 'part_count');
+    assert.greaterThanOrEqual(local_index.length, membership.length, 'local_index.length');
+
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+
+    members.forEach((member, index) => { local_index[member] = index; });
+
+    const local_addresses = new Uint32Array(members.length + 1);
+    const local_adjacency = [];
+    const local_weights = [];
+
+    members.forEach((member, index) => {
+        local_addresses[index] = local_adjacency.length;
+
+        for (let i = edge_addresses[member]; i < edge_addresses[member + 1]; i++) {
+            const other = adjacency[i];
+
+            if (membership[other] !== token) {
+                continue;
+            }
+
+            local_adjacency.push(local_index[other]);
+            local_weights.push(edge_weights[i]);
+        }
+    });
+
+    local_addresses[members.length] = local_adjacency.length;
+
+    const assignment = vgeo_partition_graph(
+        members.length,
+        part_count,
+        local_addresses,
+        Uint32Array.from(local_adjacency),
+        Float32Array.from(local_weights),
+        seed
+    );
+
+    const parts = [];
+
+    for (let i = 0; i < part_count; i++) {
+        parts.push([]);
+    }
+
+    members.forEach((member, index) => {
+        parts[assignment[index]].push(member);
+    });
+
+    return parts.filter((part) => part.length > 0);
+}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members dense face-graph vertices to split
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {number[][]} clusters, each within both caps, ordered by their lowest member so the
+ *     result does not depend on the order the recursion happened to take
+ */
+export function vgeo_split_face_set(face_graph: VGeoFaceGraph, members: number[], max_faces: number, max_vertices: number): number[][];
+//# sourceMappingURL=vgeo_split_face_set.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_split_face_set.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.js"],"names":[],"mappings":"AA6EA;;;;;;;GAOG;AACH,wEANW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CA6DtB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_split_face_set.js → partition/vgeo_split_face_set.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
+import { assert } from "../../../../../../core/assert.js";
 import { vgeo_graph_components } from "./vgeo_graph_components.js";
-import { vgeo_partition_graph } from "./vgeo_partition_graph.js";
+import { vgeo_partition_subgraph } from "./vgeo_partition_subgraph.js";
 
 /**
  * Cut a set of faces into clusters that each satisfy Shade's meshlet limits.
@@ -42,6 +42,9 @@ const SPLIT_SEED = 0xC10D;
  * what keeps clusters well filled: METIS balances what it is asked for, so `ceil(n / 128)` parts land
  * near the ceiling, while a chain of bisections lands wherever the powers of two happen to fall.
  *
+ * What this adds to {@link vgeo_partition_subgraph} is the fallback, and only this caller needs it:
+ * the recursion here has to shrink its input every time or it does not terminate.
+ *
  * @param {VGeoFaceGraph} face_graph
  * @param {number[]} members
  * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a member
@@ -50,62 +53,16 @@ const SPLIT_SEED = 0xC10D;
  * @returns {number[][]} non-empty parts; at least two of them
  */
 function partition(face_graph, members, membership, token, part_count) {
-    const graph = face_graph.graph;
-
-    const edge_addresses = graph.edge_addresses;
-    const adjacency = graph.adjacency;
-    const edge_weights = graph.edge_weights;
-
-    /**
-     * `local_index[global] = position in members`, valid only for members.
-     * @type {Uint32Array}
-     */
-    const local_index = face_graph.member_index;
-
-    members.forEach((member, index) => { local_index[member] = index; });
-
-    const local_addresses = new Uint32Array(members.length + 1);
-    const local_adjacency = [];
-    const local_weights = [];
-
-    members.forEach((member, index) => {
-        local_addresses[index] = local_adjacency.length;
-
-        for (let i = edge_addresses[member]; i < edge_addresses[member + 1]; i++) {
-            const other = adjacency[i];
-
-            if (membership[other] !== token) {
-                continue;
-            }
-
-            local_adjacency.push(local_index[other]);
-            local_weights.push(edge_weights[i]);
-        }
-    });
-
-    local_addresses[members.length] = local_adjacency.length;
-
-    const assignment = vgeo_partition_graph(
-        members.length,
+    const populated = vgeo_partition_subgraph(
+        face_graph.graph,
+        members,
+        membership,
+        token,
         part_count,
-        local_addresses,
-        Uint32Array.from(local_adjacency),
-        Float32Array.from(local_weights),
-        SPLIT_SEED
+        SPLIT_SEED,
+        face_graph.member_index
     );
 
-    const parts = [];
-
-    for (let i = 0; i < part_count; i++) {
-        parts.push([]);
-    }
-
-    members.forEach((member, index) => {
-        parts[assignment[index]].push(member);
-    });
-
-    const populated = parts.filter((part) => part.length > 0);
-
     if (populated.length >= 2) {
         return populated;
     }

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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: VGeoFaceGraph, members: number[], max_faces: number, max_vertices: number): number[][];
+//# sourceMappingURL=vgeo_split_face_set_packed.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js"],"names":[],"mappings":"AAwLA;;;;;;;;;;;;GAYG;AACH,+EALW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CAWtB"}

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

@@ -1,8 +1,8 @@
-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 { 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";
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
 import { vgeo_split_face_set } from "./vgeo_split_face_set.js";
 
 /**

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

@@ -0,0 +1,12 @@
+/**
+ * The minimal bounding sphere of a point set, rounded to float32 and inflated until it still
+ * contains every point.
+ *
+ * @param {Float32Array} points `3 * n` coordinates; at least one point
+ * @returns {Float32Array} `[x, y, z, radius]`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_bounding_sphere(points: Float32Array): Float32Array;
+//# sourceMappingURL=vgeo_bounding_sphere.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * A sphere containing every given sphere and every given point, rounded to float32 and inflated
+ * until it still does.
+ *
+ * The fit is not minimal — a minimal sphere over spheres is a different problem than the miniball
+ * solves — and the format says so: the LOD-metric spheres are "monotonically inflated, never a tight
+ * fit". Fitting the miniball to the inner centres and then growing to swallow their radii is a
+ * conservative, deterministic construction that keeps the monotonicity the cut rule depends on.
+ *
+ * @param {ArrayLike<number>[]} spheres each `[x, y, z, radius]`; may be empty when `points` is not
+ * @param {Float32Array} points `3 * n` coordinates
+ * @returns {Float32Array} `[x, y, z, radius]`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_containing_sphere(spheres: ArrayLike<number>[], points: Float32Array): Float32Array;
+//# sourceMappingURL=vgeo_containing_sphere.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Grow a stored sphere until it contains every point and every sphere it is meant to.
+ *
+ * @param {Float32Array} sphere `[x, y, z, radius]`, mutated in place
+ * @param {Float32Array} points `3 * n` coordinates
+ * @param {ArrayLike<number>[]} spheres
+ */
+export function vgeo_sphere_inflate_to_contain(sphere: Float32Array, points: Float32Array, spheres: ArrayLike<number>[]): void;
+//# sourceMappingURL=vgeo_sphere_inflate_to_contain.d.ts.map

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,24 @@
+/**
+ * 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.
+     * @type {Uint32Array}
+     */
+    vertex_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;;;OAGG;IACH,YAFU,WAAW,CAEW;CACnC"}

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

@@ -0,0 +1,20 @@
+/**
+ * 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;
+}
+//# 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;CAC1C"}

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

@@ -0,0 +1,14 @@
+/**
+ * Extract a face set into a standalone mesh, attributes and all.
+ *
+ * @param {VirtualGeometryMesh} source
+ * @param {number[]} face_ids
+ * @returns {VGeoSubmesh}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_extract_submesh(source: VirtualGeometryMesh, face_ids: number[]): VGeoSubmesh;
+import { VirtualGeometryMesh } from "../mesh/VirtualGeometryMesh.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":"AAUA;;;;;;;;;GASG;AACH,6CAPW,mBAAmB,YACnB,MAAM,EAAE,GACN,WAAW,CAyBvB;oCAhCmC,gCAAgC;4BADxC,kBAAkB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_extract_submesh.js → submesh/vgeo_extract_submesh.js}

@@ -1,12 +1,12 @@
-import { BinaryTopology } from "../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import { BinaryTopology } from "../../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
 import {
     bt_mesh_from_indexed_geometry
-} from "../../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
-import { vgeo_layers_copy_vertex } from "../format/attribute/vgeo_layers_copy_vertex.js";
-import { vgeo_layers_like } from "../format/attribute/vgeo_layers_like.js";
+} from "../../../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
+import { vgeo_layers_copy_vertex } from "../../format/attribute/vgeo_layers_copy_vertex.js";
+import { vgeo_layers_like } from "../../format/attribute/vgeo_layers_like.js";
 import { vgeo_gather_faces } from "./vgeo_gather_faces.js";
 import { VGeoSubmesh } from "./VGeoSubmesh.js";
-import { VirtualGeometryMesh } from "./VirtualGeometryMesh.js";
+import { VirtualGeometryMesh } from "../mesh/VirtualGeometryMesh.js";
 
 /**
  * Extract a face set into a standalone mesh, attributes and all.

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

@@ -0,0 +1,12 @@
+/**
+ * Gather a face set: unique vertices in first-use order, local indices, coordinates copied out.
+ *
+ * First-use order is what makes the result depend only on the face list, not on the pool's history.
+ *
+ * @param {VirtualGeometryMesh} mesh
+ * @param {number[]} face_ids allocated triangular faces
+ * @returns {VGeoGatheredFaces}
+ */
+export function vgeo_gather_faces(mesh: VirtualGeometryMesh, face_ids: number[]): VGeoGatheredFaces;
+import { VGeoGatheredFaces } from "./VGeoGatheredFaces.js";
+//# sourceMappingURL=vgeo_gather_faces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_gather_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/vgeo_gather_faces.js"],"names":[],"mappings":"AAcA;;;;;;;;GAQG;AACH,uEAHW,MAAM,EAAE,GACN,iBAAiB,CAiD7B;kCAlEiC,wBAAwB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_gather_faces.js → submesh/vgeo_gather_faces.js}

@@ -1,7 +1,7 @@
-import { assert } from "../../../../../core/assert.js";
+import { assert } from "../../../../../../core/assert.js";
 import {
     bt_face_read_triangle_vertices
-} from "../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
 import { VGeoGatheredFaces } from "./VGeoGatheredFaces.js";
 
 /**

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

@@ -0,0 +1,11 @@
+/**
+ * The 8-bit local index list a cluster payload carries.
+ *
+ * @param {VGeoGatheredFaces} gathered a face set already within the meshlet limits
+ * @returns {Uint8Array}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_narrow_indices(gathered: VGeoGatheredFaces): Uint8Array;
+//# sourceMappingURL=vgeo_narrow_indices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_narrow_indices.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/vgeo_narrow_indices.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,kEALa,UAAU,CAiBtB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_narrow_indices.js → submesh/vgeo_narrow_indices.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
-import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
-import { VGEO_MAX_CLUSTER_VERTEX_COUNT } from "../format/cluster/VGEO_MAX_CLUSTER_VERTEX_COUNT.js";
+import { assert } from "../../../../../../core/assert.js";
+import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../../format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
+import { VGEO_MAX_CLUSTER_VERTEX_COUNT } from "../../format/cluster/VGEO_MAX_CLUSTER_VERTEX_COUNT.js";
 
 /**
  * The 8-bit local index list a cluster payload carries.

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_assemble_pages.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_assemble_pages.js"],"names":[],"mappings":"AA2JA;;;;;;;;;GASG;AACH,qDAPW,sBAAsB,EAAE,iBAExB,YAAY,qBACZ,MAAM,GAEJ,mBAAmB,EAAE,CA+HjC;oCA5RmC,sCAAsC"}
+{"version":3,"file":"vgeo_assemble_pages.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_assemble_pages.js"],"names":[],"mappings":"AAwMA;;;;;;;;;GASG;AACH,qDAPW,sBAAsB,EAAE,iBAExB,YAAY,qBACZ,MAAM,GAEJ,mBAAmB,EAAE,CAiIjC;oCAzUmC,sCAAsC"}

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_build.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build.js"],"names":[],"mappings":"AA8GA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2EAFa,eAAe,CAwE3B;gCA7L+B,sBAAsB"}
+{"version":3,"file":"vgeo_build.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build.js"],"names":[],"mappings":"AA4GA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2EAFa,eAAe,CAyE3B;gCA3L+B,sBAAsB"}

package/src/shade/renderer/geometry/virtual/build/vgeo_build.js

@@ -1,16 +1,17 @@
 import { assert } from "../../../../../core/assert.js";
+import { aabb3_array_combine } from "../../../../../core/geom/3d/aabb/aabb3_array_combine.js";
 import { vgeo_attribute_mask } from "../format/attribute/vgeo_attribute_mask.js";
 import { vgeo_write_container } from "../format/vgeo_write_container.js";
 import { VGeoLevelRecord } from "../format/header/VGeoLevelRecord.js";
 import { VGeoWriteOptions } from "../format/VGeoWriteOptions.js";
-import { vgeo_assemble_pages } from "./vgeo_assemble_pages.js";
-import { vgeo_build_levels } from "./vgeo_build_levels.js";
-import { vgeo_build_root_group } from "./vgeo_build_root_group.js";
-import { vgeo_containing_sphere } from "./vgeo_containing_sphere.js";
-import { vgeo_normalize_source } from "./vgeo_normalize_source.js";
+import { vgeo_assemble_pages } from "./page/vgeo_assemble_pages.js";
+import { vgeo_build_levels } from "./level/vgeo_build_levels.js";
+import { vgeo_build_root_group } from "./level/vgeo_build_root_group.js";
+import { vgeo_containing_sphere } from "./sphere/vgeo_containing_sphere.js";
+import { vgeo_normalize_source } from "./mesh/vgeo_normalize_source.js";
 import { VGeoBuildResult } from "./VGeoBuildResult.js";
-import { VGeoLevelSummary } from "./VGeoLevelSummary.js";
-import { VirtualGeometryMesh } from "./VirtualGeometryMesh.js";
+import { VGeoLevelSummary } from "./level/VGeoLevelSummary.js";
+import { VirtualGeometryMesh } from "./mesh/VirtualGeometryMesh.js";
 
 /**
  * The whole builder pipeline, from a triangle soup to `.vgeo` bytes.
@@ -46,10 +47,7 @@ function compute_object_bounds(levels) {
         for (const cluster of level.clusters) {
             spheres.push(cluster.bounds_sphere);
 
-            for (let axis = 0; axis < 3; axis++) {
-                bounds[axis] = Math.min(bounds[axis], cluster.aabb[axis]);
-                bounds[axis + 3] = Math.max(bounds[axis + 3], cluster.aabb[axis + 3]);
-            }
+            aabb3_array_combine(bounds, 0, bounds, 0, cluster.aabb, 0);
         }
     }
 
@@ -168,6 +166,7 @@ export function vgeo_build(geometry, options) {
     const write_options = new VGeoWriteOptions();
 
     write_options.codec = options.codec;
+    write_options.codec_level = options.codec_level;
 
     // The table the header carries. A runtime reads it before any cluster record exists to it, and
     // brackets an instance's level range from the errors and radii alone — which is what lets a