@woosh/meep-engine 3.27.0 → 3.29.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_build_page_nodes.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build_page_nodes.js"],"names":[],"mappings":"AAsDA;;;;;;;;;GASG;AACH,kEAFa,uBAAuB,EAAE,CA8FrC;wCAvJuC,0CAA0C"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_build_root_group.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build_root_group.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,8EANW,MAAM,GACJ,oBAAoB,CAYhC;qCAzBoC,uCAAuC"}

package/src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_normals.d.ts

@@ -1,29 +0,0 @@
-/**
- * Area-weighted vertex normals of a mesh, written into its normal channel.
- *
- * The geometry a mesh actually has is the answer for that mesh: carrying a surviving vertex's
- * original normal through a dozen collapses shades a coarse level by whichever vertices happened to
- * win, which is visibly wrong.
- *
- * **Except where the vertex was pinned.** A pinned vertex is one the step was forbidden to move, and
- * every group that touches it carries it — which is exactly what lets a cut place two levels of
- * detail side by side without a crack. That guarantee has to cover what the vertex *carries*, not
- * only where it is: recomputed here, a pinned vertex would get the average of the faces on this
- * side of the seam only, the group across the seam would get the average of its own, and the two
- * would disagree by however much the surface turns. So a pinned vertex keeps what it had, exactly
- * as it keeps where it was, and the frame stays continuous across every cut the DAG admits.
- *
- * The pass itself is {@link bt_mesh_compute_vertex_normals}; all this adds is the pin rule and
- * lifting its result out of the topology's own normal slots and into the format's normal attribute,
- * which is where the encoder reads from.
- *
- * @param {VirtualGeometryMesh} mesh whose normal layer is sized by the vertex pool and so carries a
- *     slot for every live vertex by construction
- * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
- *     locked yet
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_vertex_normals(mesh: VirtualGeometryMesh, pinned: Set<number>): void;
-//# sourceMappingURL=vgeo_compute_vertex_normals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_compute_vertex_normals.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_normals.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EANW,IAAI,MAAM,CAAC,QAyCrB"}

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

@@ -1,75 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import {
-    bt_mesh_compute_vertex_normals
-} from "../../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_normals.js";
-import { VGEO_ATTRIBUTE } from "../format/attribute/VGEO_ATTRIBUTE.js";
-
-/**
- * One vertex's normal, on its way out of the topology's slot and into the format's channel.
- * @type {Float32Array}
- */
-const scratch_normal = new Float32Array(3);
-
-/**
- * Area-weighted vertex normals of a mesh, written into its normal channel.
- *
- * The geometry a mesh actually has is the answer for that mesh: carrying a surviving vertex's
- * original normal through a dozen collapses shades a coarse level by whichever vertices happened to
- * win, which is visibly wrong.
- *
- * **Except where the vertex was pinned.** A pinned vertex is one the step was forbidden to move, and
- * every group that touches it carries it — which is exactly what lets a cut place two levels of
- * detail side by side without a crack. That guarantee has to cover what the vertex *carries*, not
- * only where it is: recomputed here, a pinned vertex would get the average of the faces on this
- * side of the seam only, the group across the seam would get the average of its own, and the two
- * would disagree by however much the surface turns. So a pinned vertex keeps what it had, exactly
- * as it keeps where it was, and the frame stays continuous across every cut the DAG admits.
- *
- * The pass itself is {@link bt_mesh_compute_vertex_normals}; all this adds is the pin rule and
- * lifting its result out of the topology's own normal slots and into the format's normal attribute,
- * which is where the encoder reads from.
- *
- * @param {VirtualGeometryMesh} mesh whose normal layer is sized by the vertex pool and so carries a
- *     slot for every live vertex by construction
- * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
- *     locked yet
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_vertex_normals(mesh, pinned) {
-    const normals = mesh.layers[VGEO_ATTRIBUTE.NORMAL];
-
-    assert.notNull(normals, 'mesh normal channel');
-
-    const topology = mesh.topology;
-
-    bt_mesh_compute_vertex_normals(topology);
-
-    const vertex_pool = topology.vertices;
-
-    for (let vertex = 0; vertex < vertex_pool.size; vertex++) {
-        if (!vertex_pool.is_allocated(vertex)) {
-            // a released slot's normal is whatever the vertex that used to live there left behind
-            continue;
-        }
-
-        if (pinned.has(vertex)) {
-            continue;
-        }
-
-        topology.vertex_read_normal(scratch_normal, 0, vertex);
-
-        const x = scratch_normal[0];
-        const y = scratch_normal[1];
-        const z = scratch_normal[2];
-
-        if (x === 0 && y === 0 && z === 0) {
-            // An isolated or fully degenerate vertex has no surface to take a normal from; leave
-            // whatever it carried rather than inventing a direction.
-            continue;
-        }
-
-        normals.write(vertex, scratch_normal, 0);
-    }
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_compute_vertex_tangents.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_tangents.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gFANW,IAAI,MAAM,CAAC,QAmGrB"}

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

@@ -1,143 +0,0 @@
-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.
- * @type {Float32Array}
- */
-const scratch_tangent = new Float32Array(4);
-
-/**
- * One face's corners.
- * @type {Uint32Array}
- */
-const scratch_triangle = new Uint32Array(3);
-
-/**
- * Vertex 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 —
- * {@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
- * an arbitrary but well-conditioned basis around the normal — Frisvad's, via
- * {@link build_tangent_from_normal}. That is not a fallback for a broken input: a shading model that
- * reads a tangent frame reads one whether or not the surface is textured, and the alternative is
- * the format's flat default, which is parallel to the normal over a whole band of any closed
- * surface and degenerates the frame there.
- *
- * `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 {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
- *     locked yet
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_vertex_tangents(mesh, pinned) {
-    const tangents = mesh.layers[VGEO_ATTRIBUTE.TANGENT];
-    const normals = mesh.layers[VGEO_ATTRIBUTE.NORMAL];
-
-    assert.notNull(tangents, 'mesh tangent channel');
-    assert.notNull(normals, 'mesh normal channel');
-
-    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 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)) {
-                continue;
-            }
-
-            const address = vertex * 3;
-
-            build_tangent_from_normal(
-                normal_data[address], normal_data[address + 1], normal_data[address + 2],
-                0, scratch_tangent
-            );
-
-            tangents.write(vertex, 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;
-        }
-
-        topology.vertex_read_coordinate(position_data, vertex * 3, vertex);
-        uv.read(uv_data, vertex * 2, vertex);
-    }
-
-    const face_pool = topology.faces;
-
-    const indices = [];
-
-    for (let face = 0; face < face_pool.size; face++) {
-        if (!face_pool.is_allocated(face)) {
-            continue;
-        }
-
-        const read = bt_face_read_triangle_vertices(scratch_triangle, topology, face);
-
-        assert.equal(read, true, `face ${face} is not an allocated triangle`);
-
-        indices.push(scratch_triangle[0], scratch_triangle[1], scratch_triangle[2]);
-    }
-
-    const tangent_data = new Float32Array(vertex_pool_size * 4);
-
-    geometry_build_tangents(
-        indices.length, indices, vertex_pool_size,
-        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)) {
-            continue;
-        }
-
-        const address = vertex * 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
-        // word. Nothing in the solve should produce one on a mesh normalization has already passed.
-        assert.isFinite(tangent_data[address], 'tangent x');
-        assert.isFinite(tangent_data[address + 1], 'tangent y');
-        assert.isFinite(tangent_data[address + 2], 'tangent z');
-        assert.isFinite(tangent_data[address + 3], 'tangent handedness');
-
-        tangents.write(vertex, tangent_data, address);
-    }
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_containing_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_extract_submesh.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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 "./VirtualGeometryMesh.js";
-import { VGeoSubmesh } from "./VGeoSubmesh.js";
-//# sourceMappingURL=vgeo_extract_submesh.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_extract_submesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_extract_submesh.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,6CAPW,mBAAmB,YACnB,MAAM,EAAE,GACN,WAAW,CAyBvB;oCAhCmC,0BAA0B;4BADlC,kBAAkB"}

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

@@ -1,41 +0,0 @@
-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";
-import { vgeo_gather_faces } from "./vgeo_gather_faces.js";
-import { VGeoSubmesh } from "./VGeoSubmesh.js";
-import { VirtualGeometryMesh } from "./VirtualGeometryMesh.js";
-
-/**
- * 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, face_ids) {
-    const gathered = vgeo_gather_faces(source, face_ids);
-
-    const topology = new BinaryTopology();
-
-    // Before the vertices, so no record has to be widened. See {@link VirtualGeometryMesh.from_geometry}.
-    const layers = vgeo_layers_like(topology, source.layers);
-
-    bt_mesh_from_indexed_geometry(topology, gathered.indices, gathered.positions);
-
-    gathered.vertex_ids.forEach((source_vertex, local) => {
-        vgeo_layers_copy_vertex(topology, source.topology, source_vertex, local);
-    });
-
-    const result = new VGeoSubmesh();
-
-    result.mesh = new VirtualGeometryMesh(topology, layers);
-    result.source_vertex_ids = gathered.vertex_ids;
-
-    return result;
-}

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

@@ -1,12 +0,0 @@
-/**
- * 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/vgeo_gather_faces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_gather_faces.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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

@@ -1,71 +0,0 @@
-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 { VGeoGatheredFaces } from "./VGeoGatheredFaces.js";
-
-/**
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-const scratch_triangle = new Uint32Array(3);
-const scratch_coordinate = new Float32Array(3);
-
-/**
- * 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, face_ids) {
-    const topology = mesh.topology;
-
-    /**
-     * @type {Map<number, number>}
-     */
-    const local_of_source = new Map();
-
-    const vertex_ids = [];
-    const indices = new Uint32Array(face_ids.length * 3);
-
-    face_ids.forEach((face, face_index) => {
-        const read = bt_face_read_triangle_vertices(scratch_triangle, topology, face);
-
-        assert.equal(read, true, `face ${face} is not an allocated triangle`);
-
-        for (let i = 0; i < 3; i++) {
-            const vertex = scratch_triangle[i];
-
-            let local = local_of_source.get(vertex);
-
-            if (local === undefined) {
-                local = vertex_ids.length;
-
-                local_of_source.set(vertex, local);
-                vertex_ids.push(vertex);
-            }
-
-            indices[face_index * 3 + i] = local;
-        }
-    });
-
-    const result = new VGeoGatheredFaces();
-
-    result.vertex_ids = Uint32Array.from(vertex_ids);
-    result.indices = indices;
-    result.positions = new Float32Array(vertex_ids.length * 3);
-
-    vertex_ids.forEach((vertex, local) => {
-        topology.vertex_read_coordinate(scratch_coordinate, 0, vertex);
-
-        result.positions[local * 3] = scratch_coordinate[0];
-        result.positions[local * 3 + 1] = scratch_coordinate[1];
-        result.positions[local * 3 + 2] = scratch_coordinate[2];
-    });
-
-    return result;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_graph_components.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_graph_components.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;GAWG;AACH,sDARW,WAAW,aACX,WAAW,WACX,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,GACJ,MAAM,EAAE,EAAE,CAmEtB"}

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_page_node_count.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_page_node_count.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,kDAHW,MAAM,GACJ,MAAM,CA8BlB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_partition_graph.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_sphere_inflate_to_contain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_sphere_inflate_to_contain.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_split_face_set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_split_face_set.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_split_face_set.js"],"names":[],"mappings":"AAwHA;;;;;;;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_packed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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

@@ -1,207 +0,0 @@
-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.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-const scratch_triangle = new Uint32Array(3);
-const scratch_coordinate = new Float32Array(3);
-
-/**
- * The mesh vertices a set of dense face-graph vertices touches, deduplicated.
- *
- * @param {VGeoFaceGraph} face_graph
- * @param {number[]} members
- * @returns {Set<number>}
- */
-function unique_vertices(face_graph, members) {
-    const result = new Set();
-
-    for (const member of members) {
-        bt_face_read_triangle_vertices(
-            scratch_triangle, face_graph.mesh, face_graph.vertex_face_ids[member]
-        );
-
-        for (let i = 0; i < 3; i++) {
-            result.add(scratch_triangle[i]);
-        }
-    }
-
-    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;
-}
-
-/**
- * Merge under-filled pieces into shared clusters, walking them in Morton order so that whatever ends
- * up together was near each other to begin with.
- *
- * 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.
- *
- * @param {VGeoFaceGraph} face_graph
- * @param {number[][]} pieces each already within both caps
- * @param {number} max_faces
- * @param {number} max_vertices
- * @returns {number[][]}
- */
-function pack_pieces(face_graph, pieces, max_faces, max_vertices) {
-
-    if (pieces.length < 2) {
-        // nothing to merge, pass through
-        return 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]));
-
-    /**
-     *
-     * @type {number[][]}
-     */
-    const result = [];
-
-    /**
-     *
-     * @type {number[]|undefined}
-     */
-    let bin = undefined;
-    /**
-     *
-     * @type {Set<number>|undefined}
-     */
-    let bin_vertices = undefined;
-
-    for (const index of order) {
-        const piece = pieces[index];
-
-        if (bin !== undefined && (bin.length + piece.length) <= max_faces) {
-            const piece_vertices = unique_vertices(face_graph, piece);
-
-            let added = 0;
-
-            for (const vertex of piece_vertices) {
-                if (!bin_vertices.has(vertex)) {
-                    added++;
-                }
-            }
-
-            if (bin_vertices.size + added <= max_vertices) {
-                for (const member of piece) {
-                    bin.push(member);
-                }
-
-                for (const vertex of piece_vertices) {
-                    bin_vertices.add(vertex);
-                }
-
-                continue;
-            }
-        }
-
-        bin = piece.slice();
-        bin_vertices = unique_vertices(face_graph, piece);
-
-        result.push(bin);
-    }
-
-    for (const packed of result) {
-        packed.sort((a, b) => a - b);
-    }
-
-    return result;
-}
-
-/**
- * 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) {
-    const packed = pack_pieces(
-        face_graph, vgeo_split_face_set(face_graph, members, max_faces, max_vertices),
-        max_faces, max_vertices
-    );
-
-    packed.sort((a, b) => a[0] - b[0]);
-
-    return packed;
-}