@woosh/meep-engine 3.28.0 → 3.30.0

package/src/shade/renderer/geometry/virtual/build/level/vgeo_build_cluster_graph.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The cluster adjacency graph of a frontier: clusters are the vertices, shared mesh edges are the
+ * edges, and an edge weighs as much boundary as the two clusters share, discounted by how much empty
+ * space merging them would enclose.
+ *
+ * @param {VGeoFrontier} frontier
+ * @param {VGeoFaceGraph} face_graph of `frontier.mesh`
+ * @returns {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_build_cluster_graph(frontier: VGeoFrontier, face_graph: VGeoFaceGraph): {
+    edge_addresses: Uint32Array;
+    adjacency: Uint32Array;
+    edge_weights: Float32Array;
+};
+//# sourceMappingURL=vgeo_build_cluster_graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_build_cluster_graph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_cluster_graph.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;GAWG;AACH,6FALa;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC,CAqE7F"}

package/src/shade/renderer/geometry/virtual/build/level/vgeo_build_cluster_graph.js

@@ -0,0 +1,116 @@
+import {
+    sphere_compute_bounding_of_2_spheres
+} from "../../../../../../core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.js";
+
+const scratch_sphere = new Float32Array(4);
+
+/**
+ * How much of the space two clusters would waste by being merged, as a factor in `(0, 1]`.
+ *
+ * The ratio of what they occupy separately to what the sphere containing both would occupy. Two
+ * clusters side by side score near one; two clusters at opposite ends of the model score near zero,
+ * because the sphere over both is mostly empty. Scale-free by construction — it compares a volume
+ * to a volume, so it needs no notion of how big the model is or how far apart "far" is, which is
+ * exactly what a distance threshold would have needed and could never have been given.
+ *
+ * The group's sphere is what the runtime projects to decide the whole group's fate, so a group
+ * spread across empty space is one that gets refined from much further away than its geometry
+ * warrants. Cutting edge weight by this steers the partitioner away from those merges without ever
+ * forbidding one — when nothing better is available, a poor merge is still better than none.
+ *
+ * @param {Float32Array} a bounding sphere, centre then radius
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+function compactness(a, b) {
+    sphere_compute_bounding_of_2_spheres(scratch_sphere, a, b);
+
+    const merged = scratch_sphere[3];
+
+    if (merged <= 0) {
+        return 1;
+    }
+
+    // Volumes, up to the common factor of 4/3 pi, which cancels.
+    const separate = a[3] * a[3] * a[3] + b[3] * b[3] * b[3];
+
+    return Math.min(1, separate / (merged * merged * merged));
+}
+
+/**
+ * The cluster adjacency graph of a frontier: clusters are the vertices, shared mesh edges are the
+ * edges, and an edge weighs as much boundary as the two clusters share, discounted by how much empty
+ * space merging them would enclose.
+ *
+ * @param {VGeoFrontier} frontier
+ * @param {VGeoFaceGraph} face_graph of `frontier.mesh`
+ * @returns {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_build_cluster_graph(frontier, face_graph) {
+    const cluster_of_face = new Int32Array(frontier.mesh.topology.faces.size).fill(-1);
+
+    frontier.cluster_faces.forEach((face_ids, cluster) => {
+        for (const face of face_ids) {
+            cluster_of_face[face] = cluster;
+        }
+    });
+
+    const cluster_count = frontier.clusters.length;
+
+    /**
+     * `cluster -> (neighbour cluster -> shared boundary)`.
+     * @type {Map<number, number>[]}
+     */
+    const neighbours = [];
+
+    for (let i = 0; i < cluster_count; i++) {
+        neighbours.push(new Map());
+    }
+
+    const graph = face_graph.graph;
+
+    for (let vertex = 0; vertex < graph.vertex_count; vertex++) {
+        const cluster = cluster_of_face[face_graph.vertex_face_ids[vertex]];
+
+        for (let i = graph.edge_addresses[vertex]; i < graph.edge_addresses[vertex + 1]; i++) {
+            const other_cluster = cluster_of_face[face_graph.vertex_face_ids[graph.adjacency[i]]];
+
+            if (other_cluster === cluster) {
+                continue;
+            }
+
+            const bucket = neighbours[cluster];
+
+            bucket.set(other_cluster, (bucket.get(other_cluster) ?? 0) + graph.edge_weights[i]);
+        }
+    }
+
+    const edge_addresses = new Uint32Array(cluster_count + 1);
+    const adjacency = [];
+    const edge_weights = [];
+
+    for (let cluster = 0; cluster < cluster_count; cluster++) {
+        edge_addresses[cluster] = adjacency.length;
+
+        const entries = Array.from(neighbours[cluster].entries()).sort((a, b) => a[0] - b[0]);
+
+        for (const [other, weight] of entries) {
+            adjacency.push(other);
+
+            edge_weights.push(weight * compactness(
+                frontier.clusters[cluster].bounds_sphere, frontier.clusters[other].bounds_sphere
+            ));
+        }
+    }
+
+    edge_addresses[cluster_count] = adjacency.length;
+
+    return {
+        edge_addresses,
+        adjacency: Uint32Array.from(adjacency),
+        edge_weights: Float32Array.from(edge_weights),
+    };
+}

package/src/shade/renderer/geometry/virtual/build/level/vgeo_build_group_step.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Simplify one group and cut the result into the parent clusters of every cluster in it.
+ *
+ * @param {VGeoFrontier} frontier
+ * @param {number[]} group_clusters cluster indices
+ * @param {Int32Array} group_of_face one entry per face slot, holding the group each face belongs to
+ * @param {number} group_index
+ * @param {number} level of the parents this step produces
+ * @param {VGeoLevelOptions} options
+ * @returns {VGeoGroupStep|undefined} `undefined` when the group has no coarser form at all, and the
+ *     round should leave its clusters alone
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_build_group_step(frontier: VGeoFrontier, group_clusters: number[], group_of_face: Int32Array, group_index: number, level: number, options: VGeoLevelOptions): VGeoGroupStep | undefined;
+import { VGeoGroupStep } from "./VGeoGroupStep.js";
+//# sourceMappingURL=vgeo_build_group_step.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_build_group_step.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_group_step.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;GAcG;AACH,8EAXW,MAAM,EAAE,iBACR,UAAU,eACV,MAAM,SACN,MAAM,8BAEJ,aAAa,GAAC,SAAS,CAidnC;8BArgB6B,oBAAoB"}