@ifc-lite/renderer 1.43.0 → 1.44.1

package/dist/shaders/section-2d-overlay.wgsl.js

@@ -0,0 +1,281 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * WGSL shaders for the section 2D overlay (cut-cap fills + overlay lines).
+ *
+ * Two pipelines share this file because they deliberately share ONE 160-byte
+ * uniform LAYOUT: the fill shader reads `viewProj … params2` (the first 144 B)
+ * and the line shader reads `viewProj`, `planeOffset` and the appended
+ * `lineColor` at byte offset 144. They share the layout, not the storage — each
+ * draw site gets its own record in one buffer, addressed by a dynamic
+ * bind-group offset; see {@link SECTION_2D_UNIFORM_SLOT_INDEX}.
+ * The two `struct Uniforms` declarations below
+ * must therefore stay field-for-field compatible, and every TypeScript writer
+ * must address the buffer through `SECTION_2D_UNIFORM_SLOTS` rather than a
+ * hand-written index. `section-2d-uniform-layout.test.ts` parses both structs
+ * out of these sources and fails if either drifts from the slot table.
+ */
+/**
+ * Float32 indices of each field in the shared uniform buffer.
+ *
+ * WGSL std140-style layout: `mat4x4<f32>` is 64 B (16 floats) and each
+ * `vec4<f32>` is 16 B (4 floats), all naturally aligned, so the offsets are a
+ * simple running sum. These are FLOAT offsets — multiply by 4 for the byte
+ * offsets quoted in the shader comments.
+ */
+export const SECTION_2D_UNIFORM_SLOTS = {
+    /** mat4x4<f32> — floats 0..15 (bytes 0..63) */
+    viewProj: 0,
+    /** vec4<f32> — floats 16..19 (bytes 64..79) */
+    planeOffset: 16,
+    /** vec4<f32> — floats 20..23 (bytes 80..95) */
+    capFillColor: 20,
+    /** vec4<f32> — floats 24..27 (bytes 96..111) */
+    capStrokeColor: 24,
+    /** vec4<f32> x=patternId, y=spacingPx, z=angleRad, w=widthPx — floats 28..31 */
+    params: 28,
+    /** vec4<f32> x=secondaryAngleRad, y,z,w reserved — floats 32..35 */
+    params2: 32,
+    /** vec4<f32> overlay / section-cut line colour — floats 36..39 (bytes 144..159) */
+    lineColor: 36,
+};
+/** Total float count of one uniform record (40 floats = 160 bytes). */
+export const SECTION_2D_UNIFORM_FLOATS = 40;
+/** Total byte size of one uniform record. */
+export const SECTION_2D_UNIFORM_BYTES = SECTION_2D_UNIFORM_FLOATS * 4;
+/**
+ * One uniform slot per draw site.
+ *
+ * The overlay renderer issues up to six draws into a **single** render pass —
+ * the section cut cap plus five world-space line families — and every one of
+ * them needs a different `lineColor` (and, for the cap, a different
+ * `planeOffset` and the whole cap-style tail). With one record shared between
+ * them the last `queue.writeBuffer` before submit is what the GPU sees for all
+ * six: `writeBuffer` is a *queue* operation, so it is applied before the
+ * command buffer that references it executes, no matter where in the encoding
+ * it was issued. Every earlier draw therefore rendered with the last draw's
+ * uniforms — most visibly, the clash box's colour bleeding onto the annotation,
+ * alignment, grid and DXF overlays, and the cap losing its fill colour and
+ * hatch to the zeroed tail the line draws write.
+ *
+ * Each site owning a fixed slot, addressed with a dynamic bind-group offset,
+ * is what makes the six draws independent while keeping the buffer, the layout
+ * and the bind group under the single owner issue #2456 insisted on. A slot per
+ * site (rather than a bump allocator) needs no per-frame reset hook: each site
+ * draws at most once per pass.
+ */
+export const SECTION_2D_UNIFORM_SLOT_INDEX = {
+    /** The section cut cap: fill + outline, which share one record by design. */
+    sectionCut: 0,
+    annotation: 1,
+    alignment: 2,
+    grid: 3,
+    dxf: 4,
+    clashBox: 5,
+};
+/** How many uniform records the shared buffer holds. */
+export const SECTION_2D_UNIFORM_SLOT_COUNT = 6;
+/**
+ * Byte stride between uniform slots for `device`.
+ *
+ * A dynamic offset must be a multiple of `minUniformBufferOffsetAlignment`,
+ * which a device reports for itself (256 is the guaranteed-supported default,
+ * but a device may allow less). Round the 160-byte record up to that alignment
+ * rather than assuming either number.
+ */
+export function sectionUniformSlotStride(device) {
+    const alignment = device.limits?.minUniformBufferOffsetAlignment ?? 256;
+    const safe = Number.isFinite(alignment) && alignment > 0 ? alignment : 256;
+    return Math.ceil(SECTION_2D_UNIFORM_BYTES / safe) * safe;
+}
+/**
+ * Fill shader for the cut cap.
+ *
+ * Applies the user-defined cap style (fill colour + screen-space hatch) on top
+ * of the EXACT 2D section polygons produced by SectionCutter. Per-vertex colour
+ * DRIVES the fill when a polygon opts in (alpha >= 0): a material-layer
+ * wall/slab fills each layer with its own IfcMaterial colour, matching the 3D
+ * build-up. Polygons that pass the sentinel alpha -1 fall back to the uniform
+ * cap style, so single-material cuts read as one architectural section exactly
+ * as before. Hatch + stroke apply over either base.
+ */
+export const SECTION_2D_CAP_FILL_WGSL = /* wgsl */ `
+        struct Uniforms {
+          viewProj:       mat4x4<f32>,
+          planeOffset:    vec4<f32>,    // Small offset to render slightly in front of section plane
+          capFillColor:   vec4<f32>,
+          capStrokeColor: vec4<f32>,
+          // x=patternId, y=spacingPx, z=angleRad, w=widthPx
+          params:         vec4<f32>,
+          // x=secondaryAngleRad, y,z,w reserved
+          params2:        vec4<f32>,
+        }
+        @binding(0) @group(0) var<uniform> uniforms: Uniforms;
+
+        struct VertexInput {
+          @location(0) position: vec3<f32>,
+          @location(1) color:    vec4<f32>,
+        }
+
+        struct VertexOutput {
+          @builtin(position) position: vec4<f32>,
+          @location(0)       color:    vec4<f32>,
+        }
+
+        @vertex
+        fn vs_main(input: VertexInput) -> VertexOutput {
+          var output: VertexOutput;
+          let offsetPos = input.position + uniforms.planeOffset.xyz;
+          output.position = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          output.color = input.color;
+          return output;
+        }
+
+        // Screen-space hatch pattern helpers (ported from section-cap.wgsl).
+        fn lineMask(u: f32, s: f32, w: f32) -> f32 {
+          let f = fract(u / s) * s;
+          let d = min(f, s - f);
+          return 1.0 - smoothstep(w * 0.5, w * 0.5 + 1.0, d);
+        }
+        fn rotate(p: vec2<f32>, a: f32) -> vec2<f32> {
+          let c = cos(a);
+          let s = sin(a);
+          return vec2<f32>(c * p.x - s * p.y, s * p.x + c * p.y);
+        }
+        fn hatchIntensity(fragCoord: vec2<f32>, patternId: u32, spacing: f32, angle: f32, width: f32, angle2: f32) -> f32 {
+          let p = fragCoord;
+          if (patternId == 0u) { return 0.0; }          // solid
+          if (patternId == 1u) {                         // diagonal
+            let r = rotate(p, angle);
+            return lineMask(r.x, spacing, width);
+          }
+          if (patternId == 2u) {                         // cross-hatch
+            let r  = rotate(p, angle);
+            let r2 = rotate(p, angle2);
+            return max(lineMask(r.x, spacing, width), lineMask(r2.x, spacing, width));
+          }
+          if (patternId == 3u) { return lineMask(p.y, spacing, width); }    // horizontal
+          if (patternId == 4u) { return lineMask(p.x, spacing, width); }    // vertical
+          if (patternId == 5u) {
+            // Concrete (ISO 128-50): clean regular dot grid. The previous
+            // version layered dashes on top which looked noisy and broken.
+            // Dots sit at every grid intersection; radius scales with
+            // stroke width so the user's width slider works consistently.
+            let gx = p.x - round(p.x / spacing) * spacing;
+            let gy = p.y - round(p.y / spacing) * spacing;
+            let d = sqrt(gx * gx + gy * gy);
+            let radius = max(1.0, width * 1.2);
+            return 1.0 - smoothstep(radius, radius + 1.0, d);
+          }
+          if (patternId == 6u) {                         // brick
+            let bandH = spacing;
+            let band = floor(p.y / bandH);
+            // Signed parity. p is @builtin(position) today, so it is a
+            // framebuffer coordinate and never negative — but u32() of a
+            // negative float is an out-of-range conversion in WGSL, and the
+            // moment this hatch is fed anything but fragCoord (a world- or
+            // drawing-space variant) the running bond would break across
+            // y = 0 in a backend-dependent way. i32(-1) & 1 is 1, so the
+            // parity alternates correctly in both directions.
+            let offset = select(0.0, bandH, (i32(band) & 1) == 1);
+            let horiz = lineMask(p.y, bandH, width);
+            let vertPos = p.x + offset * 0.5;
+            let vert = step(fract(vertPos / (bandH * 2.0)), 0.02);
+            return max(horiz, vert);
+          }
+          if (patternId == 7u) {                         // insulation
+            let y = spacing * 0.5 * sin(p.x * 6.2831853 / spacing) + p.y;
+            return lineMask(y, spacing, width);
+          }
+          return 0.0;
+        }
+
+        struct FragOut {
+          @location(0) color:    vec4<f32>,
+          @location(1) objectId: vec4<f32>,
+        }
+
+        @fragment
+        fn fs_main(input: VertexOutput) -> FragOut {
+          let patternId = u32(uniforms.params.x + 0.5);
+          let spacing   = max(2.0, uniforms.params.y);
+          let angle     = uniforms.params.z;
+          let width     = max(1.0, uniforms.params.w);
+          let angle2    = uniforms.params2.x;
+
+          let h = hatchIntensity(input.position.xy, patternId, spacing, angle, width, angle2);
+          // Per-polygon colour (a material-layer slab fills with its own
+          // IfcMaterial RGBA) overrides the uniform cap fill when present.
+          // Polygons without a colour carry the sentinel alpha -1 and fall back
+          // to the user's cap style, byte-identically. Hatch + stroke apply over
+          // whichever base is chosen, so the architectural hatch still works.
+          let useVertex = input.color.a >= 0.0;
+          let baseFill = select(uniforms.capFillColor, input.color, useVertex);
+          let rgb = mix(baseFill.rgb, uniforms.capStrokeColor.rgb, h * uniforms.capStrokeColor.a);
+          let a   = max(baseFill.a, h * uniforms.capStrokeColor.a);
+
+          var out: FragOut;
+          out.color    = vec4<f32>(rgb, a);
+          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          return out;
+        }
+      `;
+/**
+ * Line shader for the section-cut outline and the standalone world-space line
+ * overlays (annotation / alignment / grid / DXF / clash box).
+ */
+export const SECTION_2D_OVERLAY_LINE_WGSL = /* wgsl */ `
+        // Mirrors the fill shader's uniform layout so both pipelines can share
+        // one buffer; the line shader only reads viewProj, planeOffset and the
+        // appended lineColor (byte offset 144). capFillColor/… are unused here but
+        // declared for correct field offsets.
+        struct Uniforms {
+          viewProj: mat4x4<f32>,
+          planeOffset: vec4<f32>,
+          capFillColor: vec4<f32>,
+          capStrokeColor: vec4<f32>,
+          params: vec4<f32>,
+          params2: vec4<f32>,
+          lineColor: vec4<f32>,
+        }
+        @binding(0) @group(0) var<uniform> uniforms: Uniforms;
+
+        struct VertexInput {
+          @location(0) position: vec3<f32>,
+        }
+
+        struct VertexOutput {
+          @builtin(position) position: vec4<f32>,
+        }
+
+        @vertex
+        fn vs_main(input: VertexInput) -> VertexOutput {
+          var output: VertexOutput;
+          let offsetPos = input.position + uniforms.planeOffset.xyz;
+          let clip = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          // Reverse-Z decal nudge for lines coplanar with model faces
+          // (issue #812). WebGPU forbids depthStencil.depthBias on non-
+          // triangle topologies, so we do the equivalent in clip space:
+          // adding a small positive multiple of clip.w raises NDC z by a
+          // constant after the w-divide, which under reverse-Z means
+          // "slightly closer" — enough to beat MSAA jitter on annotation
+          // lines that ride exactly on a wall/floor.
+          output.position = vec4<f32>(clip.x, clip.y, clip.z + 5e-5 * clip.w, clip.w);
+          return output;
+        }
+
+        struct FragOutLine {
+          @location(0) color:    vec4<f32>,
+          @location(1) objectId: vec4<f32>,
+        }
+
+        @fragment
+        fn fs_main(input: VertexOutput) -> FragOutLine {
+          var out: FragOutLine;
+          out.color    = uniforms.lineColor;  // consumer-themeable (defaults black)
+          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          return out;
+        }
+      `;
+//# sourceMappingURL=section-2d-overlay.wgsl.js.map

package/dist/shaders/section-2d-overlay.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"section-2d-overlay.wgsl.js","sourceRoot":"","sources":["../../src/shaders/section-2d-overlay.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,+CAA+C;IAC/C,QAAQ,EAAE,CAAC;IACX,+CAA+C;IAC/C,WAAW,EAAE,EAAE;IACf,+CAA+C;IAC/C,YAAY,EAAE,EAAE;IAChB,gDAAgD;IAChD,cAAc,EAAE,EAAE;IAClB,gFAAgF;IAChF,MAAM,EAAE,EAAE;IACV,oEAAoE;IACpE,OAAO,EAAE,EAAE;IACX,mFAAmF;IACnF,SAAS,EAAE,EAAE;CACL,CAAC;AAEX,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C,6CAA6C;AAC7C,MAAM,CAAC,MAAM,wBAAwB,GAAG,yBAAyB,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,6EAA6E;IAC7E,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC;IACZ,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,CAAC;IACN,QAAQ,EAAE,CAAC;CACH,CAAC;AAEX,wDAAwD;AACxD,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAiB;IACxD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,+BAA+B,IAAI,GAAG,CAAC;IACxE,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC;IAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwH5C,CAAC;AAER;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDhD,CAAC"}

package/dist/symbolic-overlay-pipelines.d.ts

@@ -5,11 +5,9 @@
  * viewProj)` entry point that the caller invokes from inside an existing
  * RGBA-blended render pass.
  *
- * Triangulation: simple ear-clipping for polygon-with-optional-holes,
- * inlined below to avoid adding a dependency. Good enough for typical IFC
- * fill regions (rooms, hatched zones) which are usually convex or near-convex.
- * Pathological concave shapes with many holes may show tessellation glitches —
- * an `earcut` upgrade is straightforward when it matters.
+ * Triangulation lives in `fill-triangulate.ts` and is shared with the section
+ * cut caps: rings are nested by the even-odd rule, holes are bridged in, and
+ * the result is ear-clipped.
  */
 import { SymbolicTextAtlas } from './symbolic-text-atlas.js';
 export interface SymbolicFillInput {
@@ -63,12 +61,14 @@ export declare class SymbolicFillPipeline {
     constructor(device: GPUDevice, presentationFormat: GPUTextureFormat, sampleCount?: number);
     private init;
     /**
-     * Upload a list of fill regions. Each region is triangulated (ear-clipping,
-     * holes-aware) into a single shared vertex buffer.
+     * Upload a list of fill regions. Each region is triangulated by the shared
+     * even-odd triangulator (`fill-triangulate.ts`) into a single vertex buffer.
      *
-     * Pass an empty array to clear. Triangulation skips degenerate rings
-     * (< 3 vertices) and silently drops any hole that can't be merged into the
-     * outer ring (rare; usually overlapping rings in malformed IFC).
+     * Pass an empty array to clear. Rings with fewer than 3 vertices are
+     * dropped, and so is any ring set that yields no triangle at all (a fully
+     * collinear bound). Inner bounds themselves are never dropped: since #2516
+     * the bridge always finds an anchor, so a hole cannot fall out of the
+     * result the way it used to when it "couldn't be merged".
      */
     upload(fills: readonly SymbolicFillInput[]): void;
     hasGeometry(): boolean;
@@ -107,33 +107,4 @@ export declare class SymbolicTextPipeline {
     render(pass: GPURenderPassEncoder, viewProj: Float32Array, viewportPxWidth: number, viewportPxHeight: number, cameraRight: readonly [number, number, number], cameraUp: readonly [number, number, number], targetGlyphPx?: number): void;
     destroy(): void;
 }
-/**
- * Stitch each hole into the outer ring with a single bridge edge so the
- * result is a simple polygon ear-clipping can handle. Mirrors mapbox/earcut's
- * `eliminateHoles` pass:
- *
- *   1. For each hole, pick its rightmost (max-x) vertex as the bridge start.
- *   2. Sort holes by descending bridge-start x so outer holes go in first.
- *   3. Walk the outer ring for the vertex on the right side of the bridge
- *      that's "visible" from the hole — closest match wins.
- *   4. Splice the hole (rotated to start at its bridge vertex, and reversed
- *      so its winding opposes the outer ring) into the outer ring at the
- *      anchor, closing both ends back to their starts to form a zero-area
- *      bridge edge.
- *
- * This breaks under pathological inputs (overlapping holes, holes outside
- * the outer ring) but those don't occur in well-formed `IfcAnnotationFillArea`
- * geometry — the IFC schema requires the outer bound to contain all inner
- * bounds.
- */
-export type Pt = {
-    x: number;
-    z: number;
-};
-export declare function joinHoles(outer: Pt[], holes: Pt[][]): Pt[];
-/** Ear-clipping triangulation of a simple polygon. Returns triangle vertex indices. */
-export declare function earClip(ring: ReadonlyArray<{
-    x: number;
-    z: number;
-}>): number[][];
 //# sourceMappingURL=symbolic-overlay-pipelines.d.ts.map

package/dist/symbolic-overlay-pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbolic-overlay-pipelines.d.ts","sourceRoot":"","sources":["../src/symbolic-overlay-pipelines.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"symbolic-overlay-pipelines.d.ts","sourceRoot":"","sources":["../src/symbolic-overlay-pipelines.ts"],"names":[],"mappings":"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"}

package/dist/symbolic-overlay-pipelines.js

@@ -8,15 +8,14 @@
  * viewProj)` entry point that the caller invokes from inside an existing
  * RGBA-blended render pass.
  *
- * Triangulation: simple ear-clipping for polygon-with-optional-holes,
- * inlined below to avoid adding a dependency. Good enough for typical IFC
- * fill regions (rooms, hatched zones) which are usually convex or near-convex.
- * Pathological concave shapes with many holes may show tessellation glitches —
- * an `earcut` upgrade is straightforward when it matters.
+ * Triangulation lives in `fill-triangulate.ts` and is shared with the section
+ * cut caps: rings are nested by the even-odd rule, holes are bridged in, and
+ * the result is ear-clipped.
  */
 import { SymbolicTextAtlas } from './symbolic-text-atlas.js';
 import { SYMBOLIC_FILL_WGSL, SYMBOLIC_TEXT_WGSL, } from './shaders/symbolic-overlay.wgsl.js';
 import { PIPELINE_CONSTANTS } from './constants.js';
+import { triangulateRings } from './fill-triangulate.js';
 const FILL_VERTEX_STRIDE_BYTES = (3 + 4) * 4; // pos.xyz + color.rgba, 4 bytes each
 const TEXT_INSTANCE_STRIDE_BYTES = (3 + 3 + 3 + 4 + 4 + 3 + 1 + 1 + 4 + 1) * 4;
 // origin.xyz + rightAxis.xyz + upAxis.xyz + uvBounds.xyzw + color.rgba
@@ -137,12 +136,14 @@ export class SymbolicFillPipeline {
         });
     }
     /**
-     * Upload a list of fill regions. Each region is triangulated (ear-clipping,
-     * holes-aware) into a single shared vertex buffer.
+     * Upload a list of fill regions. Each region is triangulated by the shared
+     * even-odd triangulator (`fill-triangulate.ts`) into a single vertex buffer.
      *
-     * Pass an empty array to clear. Triangulation skips degenerate rings
-     * (< 3 vertices) and silently drops any hole that can't be merged into the
-     * outer ring (rare; usually overlapping rings in malformed IFC).
+     * Pass an empty array to clear. Rings with fewer than 3 vertices are
+     * dropped, and so is any ring set that yields no triangle at all (a fully
+     * collinear bound). Inner bounds themselves are never dropped: since #2516
+     * the bridge always finds an anchor, so a hole cannot fall out of the
+     * result the way it used to when it "couldn't be merged".
      */
     upload(fills) {
         this.init();
@@ -607,14 +608,14 @@ function parseBoxAlignment(s) {
     return { horizontal, vertical };
 }
 /**
- * Triangulate a polygon-with-holes via ear-clipping. Each output triangle is
- * appended to `stream` as 3 × (x, y, z, r, g, b, a) entries (matching the
- * fill pipeline's vertex layout). Holes that fully enclose nothing or have
- * < 3 valid vertices are silently dropped.
+ * Triangulate a fill region (outer bound plus inner bounds) and append every
+ * output triangle to `stream` as 3 x (x, y, z, r, g, b, a) entries, matching
+ * the fill pipeline's vertex layout.
  *
- * Ear-clipping is O(n²) which is fine for fill regions (typically < 100
- * vertices). For pathological inputs we'd want earcut proper, but adding the
- * npm dependency for marginal gain isn't worth it.
+ * `holesOffsets` splits the flat `points` buffer into rings; rings with fewer
+ * than 3 vertices are dropped. Which of those rings are filled and which are
+ * voids is decided by nesting, not by position, so an inner bound that itself
+ * contains an island fills that island (see `fill-triangulate.ts`).
  */
 function triangulateFillTo(stream, fill) {
     const { points, holesOffsets, worldY, color } = fill;
@@ -625,7 +626,6 @@ function triangulateFillTo(stream, fill) {
     const ringStarts = [0, ...Array.from(holesOffsets), totalVerts];
     if (ringStarts.length < 2)
         return;
-    // Pull each ring's vertices out.
     const rings = [];
     for (let r = 0; r < ringStarts.length - 1; r++) {
         const start = ringStarts[r];
@@ -640,155 +640,12 @@ function triangulateFillTo(stream, fill) {
     }
     if (rings.length === 0)
         return;
-    // Stitch each hole into the outer ring with a bridge edge from the hole's
-    // rightmost vertex to the nearest outer-ring vertex (the same approach
-    // earcut.js takes for polygon-with-holes input). Ear-clipping then runs on
-    // the resulting simple polygon. The hole's winding is reversed first so the
-    // combined ring's signed area stays consistent and the ear-test sign holds.
-    const outer = rings[0];
-    const holes = rings.slice(1);
-    const stitched = holes.length === 0 ? outer : joinHoles(outer, holes);
-    const triangles = earClip(stitched);
+    const { points: verts, triangles } = triangulateRings(rings);
     for (const tri of triangles) {
         for (const idx of tri) {
-            const v = stitched[idx];
+            const v = verts[idx];
             stream.push(v.x, worldY, v.z, color[0], color[1], color[2], color[3]);
         }
     }
 }
-export function joinHoles(outer, holes) {
-    if (holes.length === 0)
-        return outer;
-    const sorted = holes
-        .map((h) => {
-        let bestI = 0;
-        for (let i = 1; i < h.length; i++) {
-            if (h[i].x > h[bestI].x)
-                bestI = i;
-        }
-        return { ring: h, startIdx: bestI, startX: h[bestI].x, startZ: h[bestI].z };
-    })
-        .sort((a, b) => b.startX - a.startX);
-    let result = outer.slice();
-    for (const { ring, startIdx, startX, startZ } of sorted) {
-        // Find the outer-ring index with the smallest distance to the bridge
-        // start, preferring vertices to the right (x > startX). When nothing is
-        // to the right (hole touches the outer ring's right edge), fall back to
-        // global nearest.
-        let bestIdx = -1;
-        let bestDist = Infinity;
-        for (let i = 0; i < result.length; i++) {
-            const p = result[i];
-            if (p.x <= startX)
-                continue;
-            const d = (p.x - startX) * (p.x - startX) + (p.z - startZ) * (p.z - startZ);
-            if (d < bestDist) {
-                bestDist = d;
-                bestIdx = i;
-            }
-        }
-        if (bestIdx < 0) {
-            for (let i = 0; i < result.length; i++) {
-                const p = result[i];
-                const d = (p.x - startX) * (p.x - startX) + (p.z - startZ) * (p.z - startZ);
-                if (d < bestDist) {
-                    bestDist = d;
-                    bestIdx = i;
-                }
-            }
-        }
-        if (bestIdx < 0)
-            continue;
-        // Hole reversed so its winding opposes outer (outer is CCW after earClip
-        // normalisation; holes should be CW for the combined ring's area to come
-        // out right). Rotate to start at the bridge vertex.
-        const reversed = ring.slice().reverse();
-        const reversedStartIdx = ring.length - 1 - startIdx;
-        const rotated = [
-            ...reversed.slice(reversedStartIdx),
-            ...reversed.slice(0, reversedStartIdx),
-        ];
-        result = [
-            ...result.slice(0, bestIdx + 1),
-            ...rotated,
-            rotated[0],
-            result[bestIdx],
-            ...result.slice(bestIdx + 1),
-        ];
-    }
-    return result;
-}
-/** Ear-clipping triangulation of a simple polygon. Returns triangle vertex indices. */
-export function earClip(ring) {
-    const n = ring.length;
-    if (n < 3)
-        return [];
-    if (n === 3)
-        return [[0, 1, 2]];
-    // Working list of indices.
-    const indices = [];
-    // Determine winding: positive shoelace = CCW; otherwise reverse so the
-    // ear-test below uses a consistent sign.
-    let area = 0;
-    for (let i = 0; i < n; i++) {
-        const a = ring[i];
-        const b = ring[(i + 1) % n];
-        area += (a.x * b.z) - (b.x * a.z);
-    }
-    const ccw = area > 0;
-    for (let i = 0; i < n; i++) {
-        indices.push(ccw ? i : n - 1 - i);
-    }
-    const triangles = [];
-    let safety = indices.length * indices.length;
-    while (indices.length > 3 && safety-- > 0) {
-        let found = false;
-        for (let i = 0; i < indices.length; i++) {
-            const ia = indices[(i + indices.length - 1) % indices.length];
-            const ib = indices[i];
-            const ic = indices[(i + 1) % indices.length];
-            const a = ring[ia];
-            const b = ring[ib];
-            const c = ring[ic];
-            // Convex check (cross product of (b-a) × (c-b) > 0 for CCW).
-            const cross = (b.x - a.x) * (c.z - b.z) - (b.z - a.z) * (c.x - b.x);
-            if (cross <= 0)
-                continue;
-            // No other vertex inside triangle (a, b, c).
-            let containsOther = false;
-            for (let j = 0; j < indices.length; j++) {
-                const ij = indices[j];
-                if (ij === ia || ij === ib || ij === ic)
-                    continue;
-                if (pointInTriangle(ring[ij], a, b, c)) {
-                    containsOther = true;
-                    break;
-                }
-            }
-            if (containsOther)
-                continue;
-            triangles.push([ia, ib, ic]);
-            indices.splice(i, 1);
-            found = true;
-            break;
-        }
-        if (!found)
-            break; // degenerate polygon — emit what we have
-    }
-    if (indices.length === 3) {
-        triangles.push([indices[0], indices[1], indices[2]]);
-    }
-    return triangles;
-}
-function pointInTriangle(p, a, b, c) {
-    const s1 = sign(p, a, b);
-    const s2 = sign(p, b, c);
-    const s3 = sign(p, c, a);
-    const hasNeg = s1 < 0 || s2 < 0 || s3 < 0;
-    const hasPos = s1 > 0 || s2 > 0 || s3 > 0;
-    return !(hasNeg && hasPos);
-}
-function sign(p1, p2, p3) {
-    return (p1.x - p3.x) * (p2.z - p3.z) - (p2.x - p3.x) * (p1.z - p3.z);
-}
 //# sourceMappingURL=symbolic-overlay-pipelines.js.map