@woosh/meep-engine 3.28.0 → 3.29.0

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_tangents.js

@@ -1,28 +1,25 @@
 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";
 import { build_tangent_from_normal } from "../../../normals/build_tangent_from_normal.js";
 import { geometry_build_tangents } from "../../../normals/geometry_build_tangents.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
 
 /**
- * One vertex's tangent, on its way into the format's channel.
+ * One corner's tangent, on its way into the format's channel.
  * @type {Float32Array}
  */
 const scratch_tangent = new Float32Array(4);
 
 /**
- * One face's corners.
- * @type {Uint32Array}
+ * One corner's normal, read back out of the channel it ships in.
+ * @type {Float32Array}
  */
-const scratch_triangle = new Uint32Array(3);
+const scratch_normal = new Float32Array(3);
 
 /**
- * Vertex tangents of a mesh, written into its tangent channel.
+ * Tangents of a mesh, written into its tangent channel.
  *
  * A tangent is a direction *in the texture parameterization*, so where the mesh carries a `UV0` this
- * is Lengyel's per-triangle solve accumulated per vertex and orthogonalized against the normal —
+ * is Lengyel's per-triangle solve accumulated per **wedge** and orthogonalized against the normal —
  * {@link geometry_build_tangents}, the same pass {@link Geometry#computeTangents} runs, so an asset
  * that goes through the virtual-geometry builder gets the frame it would have got anywhere else.
  * Where the mesh carries no UVs there is no parameterization to be tangent to, and the frame becomes
@@ -32,22 +29,26 @@ const scratch_triangle = new Uint32Array(3);
  * the format's flat default, which is parallel to the normal over a whole band of any closed
  * surface and degenerates the frame there.
  *
+ * **Per wedge, and that is not a re-indexing of a per-vertex solve.** Lengyel's accumulation is over
+ * the triangles that share a value, and at a chart boundary the two sides do not: their UVs run in
+ * different directions and averaging them gives a tangent that is tangent to neither. So the solve
+ * is fed a mesh whose *vertices are the wedges* — the same substitution the cluster gather makes,
+ * and for the same reason — and the answer comes back one per wedge, which is then written to every
+ * corner of it.
+ *
  * `pinned` carries the same meaning and the same reason as it does for
  * {@link vgeo_compute_vertex_normals}: a vertex two groups share must carry byte-identical values in
  * both, or the seam a cut is allowed to put between them shades as a crease.
  *
- * The flat arrays this builds are indexed by *vertex id*, holes and all, so a pool with released
- * slots needs no compaction and no remap — a released slot is simply a triangle corner nothing
- * names.
- *
- * @param {VirtualGeometryMesh} mesh whose tangent and normal layers are sized by the vertex pool
+ * @param {VirtualGeometryMesh} mesh whose tangent and normal layers are sized by the loop pool
  * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
  *     locked yet
+ * @param {BtWedgeSet} wedges which corners of each vertex shade as one
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_compute_vertex_tangents(mesh, pinned) {
+export function vgeo_compute_vertex_tangents(mesh, pinned, wedges) {
     const tangents = mesh.layers[VGEO_ATTRIBUTE.TANGENT];
     const normals = mesh.layers[VGEO_ATTRIBUTE.NORMAL];
 
@@ -56,49 +57,37 @@ export function vgeo_compute_vertex_tangents(mesh, pinned) {
 
     const topology = mesh.topology;
 
-    const vertex_pool = topology.vertices;
-    const vertex_pool_size = vertex_pool.size;
-
-    const normal_data = new Float32Array(vertex_pool_size * 3);
-
-    for (let vertex = 0; vertex < vertex_pool_size; vertex++) {
-        if (vertex_pool.is_allocated(vertex)) {
-            normals.read(normal_data, vertex * 3, vertex);
-        }
-    }
+    const loop_pool = topology.loops;
 
     const uv = mesh.layers[VGEO_ATTRIBUTE.UV0];
 
     if (uv === null) {
-        for (let vertex = 0; vertex < vertex_pool_size; vertex++) {
-            if (!vertex_pool.is_allocated(vertex) || pinned.has(vertex)) {
+        for (let loop = 0; loop < loop_pool.size; loop++) {
+            if (!loop_pool.is_allocated(loop)) {
+                continue;
+            }
+
+            if (pinned.has(topology.loop_read_vertex(loop))) {
                 continue;
             }
 
-            const address = vertex * 3;
+            normals.read(scratch_normal, 0, loop);
 
             build_tangent_from_normal(
-                normal_data[address], normal_data[address + 1], normal_data[address + 2],
-                0, scratch_tangent
+                scratch_normal[0], scratch_normal[1], scratch_normal[2], 0, scratch_tangent
             );
 
-            tangents.write(vertex, scratch_tangent, 0);
+            tangents.write(loop, scratch_tangent, 0);
         }
 
         return;
     }
 
-    const position_data = new Float32Array(vertex_pool_size * 3);
-    const uv_data = new Float32Array(vertex_pool_size * 2);
-
-    for (let vertex = 0; vertex < vertex_pool_size; vertex++) {
-        if (!vertex_pool.is_allocated(vertex)) {
-            continue;
-        }
+    const wedge_count = wedges.count;
 
-        topology.vertex_read_coordinate(position_data, vertex * 3, vertex);
-        uv.read(uv_data, vertex * 2, vertex);
-    }
+    const position_data = new Float32Array(wedge_count * 3);
+    const normal_data = new Float32Array(wedge_count * 3);
+    const uv_data = new Float32Array(wedge_count * 2);
 
     const face_pool = topology.faces;
 
@@ -109,26 +98,45 @@ export function vgeo_compute_vertex_tangents(mesh, pinned) {
             continue;
         }
 
-        const read = bt_face_read_triangle_vertices(scratch_triangle, topology, face);
+        const first_loop = topology.face_read_loop(face);
+
+        let loop = first_loop;
+
+        for (let corner = 0; corner < 3; corner++) {
+            const wedge = wedges.find(wedges.of_loop[loop]);
+
+            indices.push(wedge);
+
+            topology.vertex_read_coordinate(
+                position_data, wedge * 3, topology.loop_read_vertex(loop)
+            );
+
+            normals.read(normal_data, wedge * 3, loop);
+            uv.read(uv_data, wedge * 2, loop);
 
-        assert.equal(read, true, `face ${face} is not an allocated triangle`);
+            loop = topology.loop_read_next(loop);
+        }
 
-        indices.push(scratch_triangle[0], scratch_triangle[1], scratch_triangle[2]);
+        assert.equal(loop, first_loop, `face ${face} is not an allocated triangle`);
     }
 
-    const tangent_data = new Float32Array(vertex_pool_size * 4);
+    const tangent_data = new Float32Array(wedge_count * 4);
 
     geometry_build_tangents(
-        indices.length, indices, vertex_pool_size,
+        indices.length, indices, wedge_count,
         uv_data, position_data, normal_data, tangent_data
     );
 
-    for (let vertex = 0; vertex < vertex_pool_size; vertex++) {
-        if (!vertex_pool.is_allocated(vertex) || pinned.has(vertex)) {
+    for (let loop = 0; loop < loop_pool.size; loop++) {
+        if (!loop_pool.is_allocated(loop)) {
+            continue;
+        }
+
+        if (pinned.has(topology.loop_read_vertex(loop))) {
             continue;
         }
 
-        const address = vertex * 4;
+        const address = wedges.find(wedges.of_loop[loop]) * 4;
 
         // A tangent that came out non-finite is a frame the shading model cannot use and the
         // octahedral encoder cannot represent, and it would reach the asset as a silently wrong
@@ -138,6 +146,6 @@ export function vgeo_compute_vertex_tangents(mesh, pinned) {
         assert.isFinite(tangent_data[address + 2], 'tangent z');
         assert.isFinite(tangent_data[address + 3], 'tangent handedness');
 
-        tangents.write(vertex, tangent_data, address);
+        tangents.write(loop, tangent_data, address);
     }
 }

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.d.ts

@@ -34,13 +34,20 @@
  * and the fuse would then pick one of those halves to keep. Derived after it, the vertex has its
  * whole ring. Channels the source did carry are left exactly as they came.
  *
+ * **And the weld no longer flattens what it fused.** It merges *positions*, because connectivity is
+ * what it is for; the corners it re-points keep the values they arrived with, so a vertex the source
+ * split to say its two sides shade differently comes out of here still saying it. That is
+ * `WEDGE_PLAN_2026_09_18.md` §6.2, and the line it deleted was a whole module.
+ *
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
+ * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
+ *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number): number;
+export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number, crease_angle?: number): number;
 //# sourceMappingURL=vgeo_normalize_source.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,6EAPW,MAAM,GAEJ,MAAM,CAyClB"}
+{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,6EATW,MAAM,iBAEN,MAAM,GAEJ,MAAM,CA+ClB"}

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js

@@ -19,6 +19,8 @@ import {
 } from "../../../../../../core/geom/3d/topology/struct/binary/io/vertex/bt_mesh_relative_merge_distance.js";
 import { bt_mesh_validate } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_validate.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
+import { vgeo_mesh_wedges } from "../../format/attribute/vgeo_mesh_wedges.js";
+import { VGEO_CREASE_ANGLE } from "./VGEO_CREASE_ANGLE.js";
 import { vgeo_compute_vertex_normals } from "./vgeo_compute_vertex_normals.js";
 import { vgeo_compute_vertex_tangents } from "./vgeo_compute_vertex_tangents.js";
 
@@ -65,15 +67,22 @@ const NOTHING_PINNED = new Set();
  * and the fuse would then pick one of those halves to keep. Derived after it, the vertex has its
  * whole ring. Channels the source did carry are left exactly as they came.
  *
+ * **And the weld no longer flattens what it fused.** It merges *positions*, because connectivity is
+ * what it is for; the corners it re-points keep the values they arrived with, so a vertex the source
+ * split to say its two sides shade differently comes out of here still saying it. That is
+ * `WEDGE_PLAN_2026_09_18.md` §6.2, and the line it deleted was a whole module.
+ *
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
+ * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
+ *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh, weld_ratio) {
+export function vgeo_normalize_source(mesh, weld_ratio, crease_angle = VGEO_CREASE_ANGLE) {
     const topology = mesh.topology;
 
     const weld_distance = bt_mesh_relative_merge_distance(topology, weld_ratio);
@@ -101,11 +110,17 @@ export function vgeo_normalize_source(mesh, weld_ratio) {
     // Normals first: the tangent solve reads them, and a synthesized normal beside an authored
     // tangent is still the pair the frame is built from.
     if (mesh.synthesized[VGEO_ATTRIBUTE.NORMAL]) {
-        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED);
+        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED, crease_angle);
     }
 
+    /*
+     And the wedges only once the normals are settled, because a crease the pass above just made is
+     one of the things a wedge is. A tangent it has not computed yet is uniform and splits nothing,
+     and the one it is about to compute is a function of the wedge -- so this partition is the same
+     one `vgeo_build_leaf_frontier` reads back afterwards, with or without the tangent in it.
+     */
     if (mesh.synthesized[VGEO_ATTRIBUTE.TANGENT]) {
-        vgeo_compute_vertex_tangents(mesh, NOTHING_PINNED);
+        vgeo_compute_vertex_tangents(mesh, NOTHING_PINNED, vgeo_mesh_wedges(topology));
     }
 
     return weld_distance;

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_resolve_attribute_weights.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Turn the per-channel weight *ratios* an asset is built with into the per-component weights the
+ * simplifier's metric needs, against this mesh's own size.
+ *
+ * ## Why there is a weight at all
+ *
+ * An attribute quadric's gradient carries units of *attribute per length*, so what it evaluates to
+ * is dimensionless, while the geometric quadric beside it evaluates to a squared length. Summing
+ * those without saying how a unit of one compares with a unit of the other is meaningless — the
+ * answer would depend on nothing but the arbitrary range the channel happens to use. The weight is
+ * that statement: how many object-space units of position error a full unit of this channel is
+ * worth.
+ *
+ * ## Why it is a ratio
+ *
+ * For the same reason {@link VGeoBuildOptions#weld_ratio} is. A conversion is many geometries at
+ * many sizes, and a fixed distance that is right for a doorknob is wrong for a cathedral; a fraction
+ * of the geometry's own diagonal is right for both.
+ *
+ * **Resolve it once, off the source, before any pass has removed anything**, and hand the result
+ * down — every level of the DAG has to be built against the same statement, and the mesh shrinks as
+ * the build goes on.
+ *
+ * The result is indexed by *component of the attribute vector*, not by channel: a normal's three
+ * components share one ratio because they are one direction, and the simplifier wants the number
+ * beside the value it multiplies.
+ *
+ * @param {VirtualGeometryMesh} mesh
+ * @param {ArrayLike<number>} ratios one per {@link VGEO_ATTRIBUTES} entry; see
+ *     {@link VGeoBuildOptions#attribute_weight_ratios}
+ * @returns {Float64Array} one weight per component of {@link vgeo_attribute_vector_layout}'s vector;
+ *     empty where the mesh carries no travelling channel at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_resolve_attribute_weights(mesh: VirtualGeometryMesh, ratios: ArrayLike<number>): Float64Array;
+//# sourceMappingURL=vgeo_resolve_attribute_weights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_resolve_attribute_weights.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_resolve_attribute_weights.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,kFARW,UAAU,MAAM,CAAC,GAEf,YAAY,CAsCxB"}

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_resolve_attribute_weights.js

@@ -0,0 +1,81 @@
+import { assert } from "../../../../../../core/assert.js";
+import { AABB3 } from "../../../../../../core/geom/3d/aabb/AABB3.js";
+import {
+    bt_mesh_compute_bounding_box
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_compute_bounding_box.js";
+import { vgeo_attribute_vector_layout } from "./vgeo_attribute_vector_layout.js";
+
+/**
+ * @type {AABB3}
+ */
+const scratch_bounds = new AABB3();
+
+/**
+ * Turn the per-channel weight *ratios* an asset is built with into the per-component weights the
+ * simplifier's metric needs, against this mesh's own size.
+ *
+ * ## Why there is a weight at all
+ *
+ * An attribute quadric's gradient carries units of *attribute per length*, so what it evaluates to
+ * is dimensionless, while the geometric quadric beside it evaluates to a squared length. Summing
+ * those without saying how a unit of one compares with a unit of the other is meaningless — the
+ * answer would depend on nothing but the arbitrary range the channel happens to use. The weight is
+ * that statement: how many object-space units of position error a full unit of this channel is
+ * worth.
+ *
+ * ## Why it is a ratio
+ *
+ * For the same reason {@link VGeoBuildOptions#weld_ratio} is. A conversion is many geometries at
+ * many sizes, and a fixed distance that is right for a doorknob is wrong for a cathedral; a fraction
+ * of the geometry's own diagonal is right for both.
+ *
+ * **Resolve it once, off the source, before any pass has removed anything**, and hand the result
+ * down — every level of the DAG has to be built against the same statement, and the mesh shrinks as
+ * the build goes on.
+ *
+ * The result is indexed by *component of the attribute vector*, not by channel: a normal's three
+ * components share one ratio because they are one direction, and the simplifier wants the number
+ * beside the value it multiplies.
+ *
+ * @param {VirtualGeometryMesh} mesh
+ * @param {ArrayLike<number>} ratios one per {@link VGEO_ATTRIBUTES} entry; see
+ *     {@link VGeoBuildOptions#attribute_weight_ratios}
+ * @returns {Float64Array} one weight per component of {@link vgeo_attribute_vector_layout}'s vector;
+ *     empty where the mesh carries no travelling channel at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_resolve_attribute_weights(mesh, ratios) {
+    const layout = vgeo_attribute_vector_layout(mesh.layers);
+
+    const result = new Float64Array(layout.components);
+
+    if (layout.components === 0) {
+        return result;
+    }
+
+    bt_mesh_compute_bounding_box(scratch_bounds, mesh.topology);
+
+    const diagonal = Math.hypot(
+        scratch_bounds.width, scratch_bounds.height, scratch_bounds.depth
+    );
+
+    assert.greaterThan(
+        diagonal, 0,
+        'the mesh has no extent for an attribute weight to be a fraction of: every vertex is one point'
+    );
+
+    for (const channel of layout.channels) {
+        const weight = ratios[channel.attribute] * diagonal;
+
+        // A weight of zero makes the channel's whole contribution vanish from the metric and then
+        // divides the fit by it, which reaches the asset as a silently infinite value rather than as
+        // a channel that does not matter.
+        assert.greaterThan(weight, 0, `weight of attribute ${channel.attribute}`);
+
+        result.fill(weight, channel.offset, channel.offset + channel.count);
+    }
+
+    return result;
+}

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

@@ -1,9 +1,17 @@
+/**
+ * A face-adjacency graph together with the mesh it came from, kept so that repeated splits over the
+ * same level do not rebuild it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
 export class VGeoFaceGraph {
     /**
      * @param {BinaryTopology} mesh
      * @param {BinaryTopologyFaceGraph} face_graph
+     * @param {BtWedgeSet} wedges
      */
-    constructor(mesh: BinaryTopology, face_graph: BinaryTopologyFaceGraph);
+    constructor(mesh: BinaryTopology, face_graph: BinaryTopologyFaceGraph, wedges: BtWedgeSet);
     /**
      * @type {BinaryTopology}
      */
@@ -19,10 +27,15 @@ export class VGeoFaceGraph {
      */
     vertex_face_ids: Uint32Array;
     /**
-     * Scratch stamp for unique-vertex counting, one entry per mesh vertex slot.
+     * Which corners of each vertex shade as one, because that is what a cluster's vertices are.
+     * @type {BtWedgeSet}
+     */
+    wedges: BtWedgeSet;
+    /**
+     * Scratch stamp for unique-wedge counting, one entry per wedge id.
      * @type {Int32Array}
      */
-    vertex_stamp: Int32Array;
+    wedge_stamp: Int32Array;
     /**
      * Monotonic stamp value, so the scratch never needs clearing.
      * @type {number}
@@ -42,11 +55,16 @@ export class VGeoFaceGraph {
      */
     member_index: Uint32Array;
     /**
-     * How many distinct mesh vertices a set of dense face-graph vertices touches.
+     * How many distinct **wedges** a set of dense face-graph vertices touches.
+     *
+     * Wedges and not vertices, because the ceiling this feeds is the meshlet's vertex limit and a
+     * meshlet carries one record per wedge: two corners of a vertex that shade differently are two
+     * of its vertices. Counting the mesh's instead reads low at every crease and every chart
+     * boundary — measured, on a scene of separate hard-edged parts, at 240 against a cap of 128.
      *
      * @param {number[]|Int32Array} members dense face-graph vertices
      * @returns {number}
      */
-    count_unique_vertices(members: number[] | Int32Array): number;
+    count_unique_wedges(members: number[] | Int32Array): number;
 }
 //# sourceMappingURL=VGeoFaceGraph.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoFaceGraph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/VGeoFaceGraph.js"],"names":[],"mappings":"AAcA;IA4CI;;;OAGG;IACH,uEAMC;IArDD;;OAEG;IACH,qBAAY;IAEZ;;;OAGG;IACH,kBAAa;IAEb;;;OAGG;IACH,iBAFU,WAAW,CAEE;IAEvB;;;OAGG;IACH,cAFU,UAAU,CAEA;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;;OAWG;IACH,cAFU,WAAW,CAED;IAcpB;;;;;OAKG;IACH,+BAHW,MAAM,EAAE,GAAC,UAAU,GACjB,MAAM,CA2BlB;CACJ"}
+{"version":3,"file":"VGeoFaceGraph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/VGeoFaceGraph.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IAkDI;;;;OAIG;IACH,2FAOC;IA7DD;;OAEG;IACH,qBAAY;IAEZ;;;OAGG;IACH,kBAAa;IAEb;;;OAGG;IACH,iBAFU,WAAW,CAEE;IAEvB;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,aAFU,UAAU,CAED;IAEnB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;;OAWG;IACH,cAFU,WAAW,CAED;IAgBpB;;;;;;;;;;OAUG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,GACjB,MAAM,CA4BlB;CACJ"}

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

@@ -1,7 +1,3 @@
-import {
-    bt_face_read_triangle_vertices
-} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
-
 /**
  * A face-adjacency graph together with the mesh it came from, kept so that repeated splits over the
  * same level do not rebuild it.
@@ -9,9 +5,6 @@ import {
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-
-const scratch_triangle = new Uint32Array(3);
-
 export class VGeoFaceGraph {
     /**
      * @type {BinaryTopology}
@@ -31,10 +24,16 @@ export class VGeoFaceGraph {
     vertex_face_ids = null;
 
     /**
-     * Scratch stamp for unique-vertex counting, one entry per mesh vertex slot.
+     * Which corners of each vertex shade as one, because that is what a cluster's vertices are.
+     * @type {BtWedgeSet}
+     */
+    wedges = null;
+
+    /**
+     * Scratch stamp for unique-wedge counting, one entry per wedge id.
      * @type {Int32Array}
      */
-    vertex_stamp = null;
+    wedge_stamp = null;
 
     /**
      * Monotonic stamp value, so the scratch never needs clearing.
@@ -59,42 +58,50 @@ export class VGeoFaceGraph {
     /**
      * @param {BinaryTopology} mesh
      * @param {BinaryTopologyFaceGraph} face_graph
+     * @param {BtWedgeSet} wedges
      */
-    constructor(mesh, face_graph) {
+    constructor(mesh, face_graph, wedges) {
         this.mesh = mesh;
         this.graph = face_graph.graph;
         this.vertex_face_ids = face_graph.vertex_face_ids;
-        this.vertex_stamp = new Int32Array(mesh.vertices.size).fill(-1);
+        this.wedges = wedges;
+        this.wedge_stamp = new Int32Array(wedges.parent.length).fill(-1);
         this.member_index = new Uint32Array(face_graph.graph.vertex_count);
     }
 
     /**
-     * How many distinct mesh vertices a set of dense face-graph vertices touches.
+     * How many distinct **wedges** a set of dense face-graph vertices touches.
+     *
+     * Wedges and not vertices, because the ceiling this feeds is the meshlet's vertex limit and a
+     * meshlet carries one record per wedge: two corners of a vertex that shade differently are two
+     * of its vertices. Counting the mesh's instead reads low at every crease and every chart
+     * boundary — measured, on a scene of separate hard-edged parts, at 240 against a cap of 128.
      *
      * @param {number[]|Int32Array} members dense face-graph vertices
      * @returns {number}
      */
-    count_unique_vertices(members) {
+    count_unique_wedges(members) {
         const stamp = this.stamp++;
 
         let count = 0;
 
         const vertex_face_ids = this.vertex_face_ids;
         const mesh = this.mesh;
-        const vertex_stamp = this.vertex_stamp;
+        const wedges = this.wedges;
+        const wedge_stamp = this.wedge_stamp;
 
         for (const member of members) {
+            let loop = mesh.face_read_loop(vertex_face_ids[member]);
 
-            const face = vertex_face_ids[member];
-            bt_face_read_triangle_vertices(scratch_triangle, mesh, face);
+            for (let corner = 0; corner < 3; corner++) {
+                const wedge = wedges.find(wedges.of_loop[loop]);
 
-            for (let i = 0; i < 3; i++) {
-                const vertex = scratch_triangle[i];
-
-                if (vertex_stamp[vertex] !== stamp) {
-                    vertex_stamp[vertex] = stamp;
+                if (wedge_stamp[wedge] !== stamp) {
+                    wedge_stamp[wedge] = stamp;
                     count++;
                 }
+
+                loop = mesh.loop_read_next(loop);
             }
         }
 

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

@@ -115,7 +115,7 @@ export function vgeo_split_face_set(face_graph, members, max_faces, max_vertices
         for (const component of components) {
             if (
                 component.length <= max_faces
-                && face_graph.count_unique_vertices(component) <= max_vertices
+                && face_graph.count_unique_wedges(component) <= max_vertices
             ) {
                 result.push(component);
 

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

@@ -1 +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"}
+{"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":"AAmVA;;;;;;;;;;;;GAYG;AACH,+EALW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CAoBtB"}