@woosh/meep-engine 2.164.0 → 2.165.0

package/src/core/geom/3d/atlas/atlas_extract_chart.js

@@ -0,0 +1,107 @@
+import { Chart } from "./Chart.js";
+
+// Module-static, version-stamped vertex -> chart-local map, reused across calls
+// so each extraction is O(its faces) with no per-chart O(vertices)
+// allocation/fill. `_stamp[v] === _generation` means v is already mapped this
+// call, and `_local[v]` is its chart-local index. Not re-entrant — one
+// extraction at a time (the multi-chart driver calls these sequentially).
+let _stamp = new Int32Array(0);
+let _local = new Int32Array(0);
+let _generation = 0;
+
+/**
+ * Extract a single chart from a segmented mesh into a {@link Chart} for
+ * parameterization and packing (xatlas chart construction). `boundary_edges` is
+ * flat pairs of chart-local vertex indices forming the chart outline; `uv` is
+ * zero-filled for the solver.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {Int32Array} face_chart from atlas_segment_charts (face -> chart id, -1 if none)
+ * @param {number} chart_id
+ * @param {number[]} [face_list] the chart's face ids; when omitted they are found
+ *   by scanning the whole mesh. The multi-chart driver precomputes one bucket per
+ *   chart so it does not re-scan all faces once per chart (O(charts × faces)).
+ * @returns {Chart}
+ */
+export function atlas_extract_chart(mesh, face_chart, chart_id, face_list) {
+    const faces = mesh.faces;
+
+    if (face_list === undefined) {
+        face_list = [];
+        const face_count = faces.size;
+        for (let f = 0; f < face_count; f++) {
+            if (faces.is_allocated(f) && face_chart[f] === chart_id) {
+                face_list.push(f);
+            }
+        }
+    }
+
+    const vsize = mesh.vertices.size;
+    if (_stamp.length < vsize) {
+        _stamp = new Int32Array(vsize);
+        _local = new Int32Array(vsize);
+    }
+    _generation++;
+    const gen = _generation;
+
+    const vertex_of_local = [];
+    const positions = [];
+    const tri_local = [];
+    const tri_loops = [];
+    const tri_face = [];
+    const boundary_edges = [];
+
+    const scratch = [0, 0, 0];
+
+    for (const f of face_list) {
+        const corners = [0, 0, 0];
+        const loops = [0, 0, 0];
+
+        let l = mesh.face_read_loop(f);
+        for (let i = 0; i < 3; i++) {
+            const v = mesh.loop_read_vertex(l);
+            let lv;
+            if (_stamp[v] === gen) {
+                lv = _local[v];
+            } else {
+                lv = vertex_of_local.length;
+                _stamp[v] = gen;
+                _local[v] = lv;
+                vertex_of_local.push(v);
+                mesh.vertex_read_coordinate(scratch, 0, v);
+                positions.push(scratch[0], scratch[1], scratch[2]);
+            }
+            corners[i] = lv;
+            loops[i] = l;
+            l = mesh.loop_read_next(l);
+        }
+
+        tri_local.push(corners[0], corners[1], corners[2]);
+        tri_loops.push(loops[0], loops[1], loops[2]);
+        tri_face.push(f);
+
+        // a loop's edge is a chart boundary if its radial neighbour leaves the chart
+        for (let i = 0; i < 3; i++) {
+            const li = loops[i];
+            const opp = mesh.loop_read_radial_next(li);
+            const is_boundary = opp === li || face_chart[mesh.loop_read_face(opp)] !== chart_id;
+            if (is_boundary) {
+                boundary_edges.push(corners[i], corners[(i + 1) % 3]);
+            }
+        }
+    }
+
+    const vertex_count = vertex_of_local.length;
+
+    const chart = new Chart();
+    chart.vertex_count = vertex_count;
+    chart.vertex_of_local = Uint32Array.from(vertex_of_local);
+    chart.positions = Float64Array.from(positions);
+    chart.triangle_count = tri_face.length;
+    chart.tri_local = Uint32Array.from(tri_local);
+    chart.tri_loops = Uint32Array.from(tri_loops);
+    chart.tri_face = Uint32Array.from(tri_face);
+    chart.boundary_edges = Uint32Array.from(boundary_edges);
+    chart.uv = new Float64Array(vertex_count * 2);
+    return chart;
+}

package/src/core/geom/3d/atlas/atlas_generate.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One-call UV atlas generation for a single mesh: segment it into charts,
+ * parameterize each, pack them into one atlas, then actualize the packed
+ * per-corner UVs onto the mesh via {@link atlas_write_chart_uvs} — the meep
+ * equivalent of running xatlas `ComputeCharts` then `PackCharts`. Neither
+ * {@link atlas_compute_charts} nor {@link atlas_pack_charts} touches the mesh's
+ * loop UVs; this convenience entry point performs that final write itself, so the
+ * UVs land in the loop_data channel ({@link bt_loop_read_uv}). The returned charts
+ * also carry their final atlas-space UVs and placement.
+ *
+ * To atlas several meshes into one shared atlas, drive the steps directly:
+ * {@link atlas_compute_charts} per mesh, {@link atlas_pack_charts} on the
+ * combined charts, then {@link atlas_write_chart_uvs} once per source mesh.
+ *
+ * @param {BinaryTopology} mesh mutated in place (weld, normals, loop UVs)
+ * @param {object} [options]
+ * @param {boolean} [options.weld] colocal-weld first (default true)
+ * @param {object} [options.segment] atlas_segment_charts overrides
+ * @param {object} [options.lscm] atlas_chart_parameterize_lscm overrides
+ * @param {object} [options.pack] atlas_pack_charts overrides (padding, resolution, texelsPerUnit)
+ * @returns {{charts:Chart[], chart_count:number, atlas_width:number,
+ *   atlas_height:number, utilization:number, occupied_texels:number,
+ *   mask_texels_total:number}}
+ */
+export function atlas_generate(mesh: BinaryTopology, options?: {
+    weld?: boolean;
+    segment?: object;
+    lscm?: object;
+    pack?: object;
+}): {
+    charts: Chart[];
+    chart_count: number;
+    atlas_width: number;
+    atlas_height: number;
+    utilization: number;
+    occupied_texels: number;
+    mask_texels_total: number;
+};
+//# sourceMappingURL=atlas_generate.d.ts.map

package/src/core/geom/3d/atlas/atlas_generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_generate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/atlas/atlas_generate.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAR6B,IAAI,GAAtB,OAAO;IACU,OAAO,GAAxB,MAAM;IACW,IAAI,GAArB,MAAM;IACW,IAAI,GAArB,MAAM;IACJ;IAAC,MAAM,EAAC,OAAO,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IACpE,YAAgB,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IAAC,eAAe,EAAC,MAAM,CAAC;IACpE,iBAAqB,EAAC,MAAM,CAAA;CAAC,CAgB7B"}

package/src/core/geom/3d/atlas/atlas_generate.js

@@ -0,0 +1,43 @@
+import { atlas_compute_charts } from "./atlas_compute_charts.js";
+import { atlas_write_chart_uvs } from "./atlas_write_chart_uvs.js";
+import { atlas_pack_charts } from "./pack/atlas_pack_charts.js";
+
+/**
+ * One-call UV atlas generation for a single mesh: segment it into charts,
+ * parameterize each, pack them into one atlas, then actualize the packed
+ * per-corner UVs onto the mesh via {@link atlas_write_chart_uvs} — the meep
+ * equivalent of running xatlas `ComputeCharts` then `PackCharts`. Neither
+ * {@link atlas_compute_charts} nor {@link atlas_pack_charts} touches the mesh's
+ * loop UVs; this convenience entry point performs that final write itself, so the
+ * UVs land in the loop_data channel ({@link bt_loop_read_uv}). The returned charts
+ * also carry their final atlas-space UVs and placement.
+ *
+ * To atlas several meshes into one shared atlas, drive the steps directly:
+ * {@link atlas_compute_charts} per mesh, {@link atlas_pack_charts} on the
+ * combined charts, then {@link atlas_write_chart_uvs} once per source mesh.
+ *
+ * @param {BinaryTopology} mesh mutated in place (weld, normals, loop UVs)
+ * @param {object} [options]
+ * @param {boolean} [options.weld] colocal-weld first (default true)
+ * @param {object} [options.segment] atlas_segment_charts overrides
+ * @param {object} [options.lscm] atlas_chart_parameterize_lscm overrides
+ * @param {object} [options.pack] atlas_pack_charts overrides (padding, resolution, texelsPerUnit)
+ * @returns {{charts:Chart[], chart_count:number, atlas_width:number,
+ *   atlas_height:number, utilization:number, occupied_texels:number,
+ *   mask_texels_total:number}}
+ */
+export function atlas_generate(mesh, options = {}) {
+    const computed = atlas_compute_charts(mesh, options);
+    const packed = atlas_pack_charts(computed.charts, options.pack);
+    atlas_write_chart_uvs(mesh, computed.charts);
+
+    return {
+        charts: computed.charts,
+        chart_count: computed.chart_count,
+        atlas_width: packed.atlas_width,
+        atlas_height: packed.atlas_height,
+        utilization: packed.utilization,
+        occupied_texels: packed.occupied_texels,
+        mask_texels_total: packed.mask_texels_total,
+    };
+}

package/src/core/geom/3d/atlas/atlas_test_fixtures.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Shared inline mesh fixtures for the atlas test suites. Each builder returns a
+ * fresh {@link BinaryTopology} with face normals computed. Test-only — not
+ * imported by production code.
+ */
+/**
+ * @param {number[]} indices
+ * @param {number[]} positions flat xyz
+ * @returns {BinaryTopology}
+ */
+export function atlas_make_mesh(indices: number[], positions: number[]): BinaryTopology;
+/**
+ * Unit square in the z=0 plane, two triangles sharing the 0-2 diagonal.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_unit_quad(): BinaryTopology;
+/**
+ * Two triangles sharing edge (0,1), folded to a 90 degree dihedral.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_folded_pair(): BinaryTopology;
+/**
+ * The unit quad, but the two triangles use SEPARATE vertex indices at the
+ * shared diagonal (coincident positions, distinct ids). Before welding the two
+ * triangles are two islands; after welding they share the diagonal edge.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_split_quad(): BinaryTopology;
+/**
+ * An open ribbon of `segments` quads bent around an arc of `total_angle`
+ * radians, so face normals fan out radially. Drives curvature-based chart
+ * splitting. Connected, single island, boundary on all four sides.
+ *
+ * @param {number} segments
+ * @param {number} total_angle radians swept across the ribbon
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_curved_ribbon(segments: number, total_angle: number): BinaryTopology;
+/**
+ * Flat n×n grid of quads in the z=0 plane (2·n·n coplanar triangles). All faces
+ * share one normal, so they collapse to a single planar region — the canonical
+ * region-atomic case.
+ *
+ * @param {number} n cells per side
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_grid_plane(n: number): BinaryTopology;
+/**
+ * A good quad plus three deliberately degenerate triangles (each its own
+ * island): a collinear zero-area triangle, a coincident-vertex "needle" (two
+ * vertices at the same position), and a near-collinear sliver. Real exported /
+ * scanned meshes contain these; the pipeline must stay finite and not crash.
+ * Use with `weld: false` so the needle's coincident vertices stay distinct.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_degenerate_mix(): BinaryTopology;
+/**
+ * Unit UV sphere with `rings` latitude bands and `sectors` longitude segments,
+ * shared vertices (pole fans + modulo longitude wrap), consistent winding. A
+ * smooth closed surface for testing curvature-driven segmentation.
+ *
+ * @param {number} rings latitude bands (>= 2)
+ * @param {number} sectors longitude segments (>= 3)
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_uv_sphere(rings: number, sectors: number): BinaryTopology;
+/**
+ * Regular octahedron: a closed surface of 8 triangles, outward winding.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_octahedron(): BinaryTopology;
+/**
+ * Axis-aligned unit cube, 12 triangles, consistent outward winding.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_unit_cube(): BinaryTopology;
+import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
+//# sourceMappingURL=atlas_test_fixtures.d.ts.map

package/src/core/geom/3d/atlas/atlas_test_fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/atlas/atlas_test_fixtures.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;;GAIG;AACH,yCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,cAAc,CAO1B;AAED;;;;GAIG;AACH,yCAFa,cAAc,CAY1B;AAED;;;;GAIG;AACH,2CAFa,cAAc,CAY1B;AAED;;;;;;GAMG;AACH,0CAFa,cAAc,CAc1B;AAED;;;;;;;;GAQG;AACH,oDAJW,MAAM,eACN,MAAM,GACJ,cAAc,CAsB1B;AAED;;;;;;;GAOG;AACH,0CAHW,MAAM,GACJ,cAAc,CAuB1B;AAED;;;;;;;;GAQG;AACH,8CAFa,cAAc,CA0B1B;AAED;;;;;;;;GAQG;AACH,6CAJW,MAAM,WACN,MAAM,GACJ,cAAc,CAkC1B;AAED;;;;GAIG;AACH,0CAFa,cAAc,CAiB1B;AAED;;;;GAIG;AACH,yCAFa,cAAc,CAuB1B;+BAzQ8B,6CAA6C"}

package/src/core/geom/3d/atlas/atlas_test_fixtures.js

@@ -0,0 +1,266 @@
+import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
+import { bt_mesh_compute_face_normals } from "../topology/struct/binary/io/bt_mesh_compute_face_normals.js";
+import { bt_mesh_from_indexed_geometry } from "../topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
+
+/**
+ * Shared inline mesh fixtures for the atlas test suites. Each builder returns a
+ * fresh {@link BinaryTopology} with face normals computed. Test-only — not
+ * imported by production code.
+ */
+
+/**
+ * @param {number[]} indices
+ * @param {number[]} positions flat xyz
+ * @returns {BinaryTopology}
+ */
+export function atlas_make_mesh(indices, positions) {
+    const mesh = new BinaryTopology();
+    bt_mesh_from_indexed_geometry(mesh, indices, positions);
+    bt_mesh_compute_face_normals(mesh);
+    return mesh;
+}
+
+/**
+ * Unit square in the z=0 plane, two triangles sharing the 0-2 diagonal.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_unit_quad() {
+    return atlas_make_mesh(
+        [0, 1, 2, 0, 2, 3],
+        [
+            0, 0, 0,
+            1, 0, 0,
+            1, 1, 0,
+            0, 1, 0,
+        ]
+    );
+}
+
+/**
+ * Two triangles sharing edge (0,1), folded to a 90 degree dihedral.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_folded_pair() {
+    return atlas_make_mesh(
+        [0, 1, 2, 0, 3, 1],
+        [
+            0, 0, 0,
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1,
+        ]
+    );
+}
+
+/**
+ * The unit quad, but the two triangles use SEPARATE vertex indices at the
+ * shared diagonal (coincident positions, distinct ids). Before welding the two
+ * triangles are two islands; after welding they share the diagonal edge.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_split_quad() {
+    return atlas_make_mesh(
+        [0, 1, 2, 3, 4, 5],
+        [
+            0, 0, 0,
+            1, 0, 0,
+            1, 1, 0,
+            0, 0, 0,  // duplicate of vertex 0
+            1, 1, 0,  // duplicate of vertex 2
+            0, 1, 0,
+        ]
+    );
+}
+
+/**
+ * An open ribbon of `segments` quads bent around an arc of `total_angle`
+ * radians, so face normals fan out radially. Drives curvature-based chart
+ * splitting. Connected, single island, boundary on all four sides.
+ *
+ * @param {number} segments
+ * @param {number} total_angle radians swept across the ribbon
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_curved_ribbon(segments, total_angle) {
+    const positions = [];
+    const N = segments;
+    // bottom ring at z=0 (indices 0..N), top ring at z=1 (indices N+1..2N+1)
+    for (let j = 0; j <= N; j++) {
+        const a = (j / N) * total_angle;
+        positions.push(Math.cos(a), Math.sin(a), 0);
+    }
+    for (let j = 0; j <= N; j++) {
+        const a = (j / N) * total_angle;
+        positions.push(Math.cos(a), Math.sin(a), 1);
+    }
+
+    const top = N + 1;
+    const indices = [];
+    for (let j = 0; j < N; j++) {
+        indices.push(j, j + 1, top + j + 1);
+        indices.push(j, top + j + 1, top + j);
+    }
+    return atlas_make_mesh(indices, positions);
+}
+
+/**
+ * Flat n×n grid of quads in the z=0 plane (2·n·n coplanar triangles). All faces
+ * share one normal, so they collapse to a single planar region — the canonical
+ * region-atomic case.
+ *
+ * @param {number} n cells per side
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_grid_plane(n) {
+    const positions = [];
+    for (let j = 0; j <= n; j++) {
+        for (let i = 0; i <= n; i++) {
+            positions.push(i / n, j / n, 0);
+        }
+    }
+    /**
+     * @param {number} i column index
+     * @param {number} j row index
+     * @returns {number} flat vertex id in the (n+1)×(n+1) grid
+     */
+    const idx = (i, j) => j * (n + 1) + i;
+    const indices = [];
+    for (let j = 0; j < n; j++) {
+        for (let i = 0; i < n; i++) {
+            const a = idx(i, j), b = idx(i + 1, j), c = idx(i + 1, j + 1), d = idx(i, j + 1);
+            indices.push(a, b, c, a, c, d);
+        }
+    }
+    return atlas_make_mesh(indices, positions);
+}
+
+/**
+ * A good quad plus three deliberately degenerate triangles (each its own
+ * island): a collinear zero-area triangle, a coincident-vertex "needle" (two
+ * vertices at the same position), and a near-collinear sliver. Real exported /
+ * scanned meshes contain these; the pipeline must stay finite and not crash.
+ * Use with `weld: false` so the needle's coincident vertices stay distinct.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_degenerate_mix() {
+    return atlas_make_mesh(
+        [
+            0, 1, 2, 0, 2, 3,   // good unit quad
+            4, 5, 6,            // collinear -> exactly zero area
+            7, 8, 9,            // needle: vertices 7 and 8 coincide -> zero area
+            10, 11, 12,         // near-collinear -> tiny-area sliver
+        ],
+        [
+            0, 0, 0,            // 0
+            1, 0, 0,            // 1
+            1, 1, 0,            // 2
+            0, 1, 0,            // 3
+            2, 0, 0,            // 4
+            3, 0, 0,            // 5  (4,5,6 collinear on y=0)
+            4, 0, 0,            // 6
+            2, 2, 0,            // 7
+            2, 2, 0,            // 8  coincident with 7
+            3, 2, 0,            // 9
+            2, 3, 0,            // 10
+            4, 3, 0,            // 11
+            3, 3.0001, 0,       // 12 just off the 10-11 line -> sliver
+        ]
+    );
+}
+
+/**
+ * Unit UV sphere with `rings` latitude bands and `sectors` longitude segments,
+ * shared vertices (pole fans + modulo longitude wrap), consistent winding. A
+ * smooth closed surface for testing curvature-driven segmentation.
+ *
+ * @param {number} rings latitude bands (>= 2)
+ * @param {number} sectors longitude segments (>= 3)
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_uv_sphere(rings, sectors) {
+    const positions = [];
+    positions.push(0, 1, 0);  // 0: north pole (latitude band 0)
+    positions.push(0, -1, 0); // 1: south pole (latitude band `rings`)
+    for (let i = 1; i < rings; i++) {
+        const phi = (i / rings) * Math.PI;
+        const y = Math.cos(phi);
+        const r = Math.sin(phi);
+        for (let s = 0; s < sectors; s++) {
+            const theta = (s / sectors) * 2 * Math.PI;
+            positions.push(r * Math.cos(theta), y, r * Math.sin(theta));
+        }
+    }
+
+    const vid = (i, s) => {
+        if (i === 0) return 0;
+        if (i === rings) return 1;
+        return 2 + (i - 1) * sectors + (s % sectors);
+    };
+
+    const indices = [];
+    const tri = (a, b, c) => {
+        if (a !== b && b !== c && a !== c) indices.push(a, b, c);
+    };
+    for (let i = 0; i < rings; i++) {
+        for (let s = 0; s < sectors; s++) {
+            const v00 = vid(i, s), v01 = vid(i, s + 1), v10 = vid(i + 1, s), v11 = vid(i + 1, s + 1);
+            tri(v00, v10, v11);
+            tri(v00, v11, v01);
+        }
+    }
+    return atlas_make_mesh(indices, positions);
+}
+
+/**
+ * Regular octahedron: a closed surface of 8 triangles, outward winding.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_octahedron() {
+    return atlas_make_mesh(
+        [
+            4, 0, 2, 4, 2, 1, 4, 1, 3, 4, 3, 0, // top (+z apex)
+            5, 2, 0, 5, 1, 2, 5, 3, 1, 5, 0, 3, // bottom (-z apex)
+        ],
+        [
+            1, 0, 0,
+            -1, 0, 0,
+            0, 1, 0,
+            0, -1, 0,
+            0, 0, 1,
+            0, 0, -1,
+        ]
+    );
+}
+
+/**
+ * Axis-aligned unit cube, 12 triangles, consistent outward winding.
+ *
+ * @returns {BinaryTopology}
+ */
+export function atlas_build_unit_cube() {
+    return atlas_make_mesh(
+        [
+            0, 1, 5, 0, 5, 4, // front  (-y)
+            1, 2, 6, 1, 6, 5, // right  (+x)
+            2, 3, 7, 2, 7, 6, // back   (+y)
+            3, 0, 4, 3, 4, 7, // left   (-x)
+            3, 2, 1, 3, 1, 0, // bottom (-z)
+            4, 5, 6, 4, 6, 7, // top    (+z)
+        ],
+        [
+            0, 0, 0,
+            1, 0, 0,
+            1, 1, 0,
+            0, 1, 0,
+            0, 0, 1,
+            1, 0, 1,
+            1, 1, 1,
+            0, 1, 1,
+        ]
+    );
+}

package/src/core/geom/3d/atlas/atlas_write_chart_uvs.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Actualize chart UVs into a mesh's per-corner loop_data channel — the final,
+ * explicit step of the atlas pipeline.
+ *
+ * The pipeline works at the {@link Chart} level: {@link atlas_compute_charts}
+ * produces charts and {@link atlas_pack_charts} mutates each chart's `uv` in
+ * place (to packed atlas-space coordinates). Writing those UVs back onto a mesh
+ * is deliberately a separate call the caller controls, so charts from several
+ * meshes can be packed into one atlas and then actualized independently — invoke
+ * this once per source mesh with that mesh's own charts.
+ *
+ * `chart.tri_loops` index loops in `mesh`, so every chart passed here must have
+ * been computed from `mesh` (via {@link atlas_compute_charts} on it). Whatever is
+ * currently in each `chart.uv` is written, so call this after packing for final
+ * atlas UVs (or after compute alone for the unpacked, per-chart UVs).
+ *
+ * Note: the loop_data channel is float32, so `chart.uv` (f64) is quantized to f32
+ * precision on write.
+ *
+ * @param {BinaryTopology} mesh receives the per-corner UVs (loop_data is initialized if absent)
+ * @param {Chart[]} charts charts originating from `mesh`
+ * @returns {void}
+ */
+export function atlas_write_chart_uvs(mesh: BinaryTopology, charts: Chart[]): void;
+//# sourceMappingURL=atlas_write_chart_uvs.d.ts.map

package/src/core/geom/3d/atlas/atlas_write_chart_uvs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_write_chart_uvs.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/atlas/atlas_write_chart_uvs.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oEAHW,OAAO,GACL,IAAI,CAYhB"}

package/src/core/geom/3d/atlas/atlas_write_chart_uvs.js

@@ -0,0 +1,36 @@
+import { bt_loop_uv_init, bt_loop_write_uv } from "./io/bt_loop_uv.js";
+
+/**
+ * Actualize chart UVs into a mesh's per-corner loop_data channel — the final,
+ * explicit step of the atlas pipeline.
+ *
+ * The pipeline works at the {@link Chart} level: {@link atlas_compute_charts}
+ * produces charts and {@link atlas_pack_charts} mutates each chart's `uv` in
+ * place (to packed atlas-space coordinates). Writing those UVs back onto a mesh
+ * is deliberately a separate call the caller controls, so charts from several
+ * meshes can be packed into one atlas and then actualized independently — invoke
+ * this once per source mesh with that mesh's own charts.
+ *
+ * `chart.tri_loops` index loops in `mesh`, so every chart passed here must have
+ * been computed from `mesh` (via {@link atlas_compute_charts} on it). Whatever is
+ * currently in each `chart.uv` is written, so call this after packing for final
+ * atlas UVs (or after compute alone for the unpacked, per-chart UVs).
+ *
+ * Note: the loop_data channel is float32, so `chart.uv` (f64) is quantized to f32
+ * precision on write.
+ *
+ * @param {BinaryTopology} mesh receives the per-corner UVs (loop_data is initialized if absent)
+ * @param {Chart[]} charts charts originating from `mesh`
+ * @returns {void}
+ */
+export function atlas_write_chart_uvs(mesh, charts) {
+    bt_loop_uv_init(mesh);
+    for (const chart of charts) {
+        for (let t = 0; t < chart.triangle_count; t++) {
+            for (let i = 0; i < 3; i++) {
+                const lv = chart.tri_local[t * 3 + i];
+                bt_loop_write_uv(mesh, chart.tri_loops[t * 3 + i], chart.uv[lv * 2], chart.uv[lv * 2 + 1]);
+            }
+        }
+    }
+}

package/src/core/geom/3d/atlas/data/atlas_build_edge_dihedrals.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-edge dihedral measure: the dot product of the two adjacent (unit) face
+ * normals. 1 = coplanar/flat, 0 = 90 degree fold, -1 = fully folded back.
+ * Boundary/wire/unallocated edges get {@link EDGE_DIHEDRAL_BOUNDARY}.
+ *
+ * For a non-manifold edge (>2 incident faces) the first radial pair is used.
+ *
+ * Precondition: face normals are populated (call
+ * {@link bt_mesh_compute_face_normals} first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.edges.size
+ */
+export function atlas_build_edge_dihedrals(mesh: BinaryTopology): Float32Array;
+/**
+ * Sentinel value for an edge that does not have two adjacent faces (mesh
+ * boundary, wire edge, or unallocated). Chosen outside the valid cosine range
+ * [-1, 1] so it is unambiguous. xatlas uses FLT_MAX for the same purpose.
+ * @type {number}
+ */
+export const EDGE_DIHEDRAL_BOUNDARY: number;
+//# sourceMappingURL=atlas_build_edge_dihedrals.d.ts.map

package/src/core/geom/3d/atlas/data/atlas_build_edge_dihedrals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_build_edge_dihedrals.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/data/atlas_build_edge_dihedrals.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;GAYG;AACH,kEAFa,YAAY,CAoCxB;AA1DD;;;;;GAKG;AACH,qCAFU,MAAM,CAEwB"}