three-text 0.6.1 → 0.6.2

package/README.md

@@ -19,8 +19,6 @@ High fidelity 3D text rendering and layout for the web
 
 The library has a framework-agnostic core with lightweight adapters for [Three.js](https://threejs.org), [React Three Fiber](https://docs.pmnd.rs/react-three-fiber), [p5.js](https://p5js.org), [WebGL](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API), and [WebGPU](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API)
 
-Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/harfbuzz/harfbuzzjs) (based on [HarfBuzz](https://github.com/harfbuzz/harfbuzz) by Behdad Esfahbod et al) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking (with [SILE](https://github.com/sile-typesetter/sile/blob/master/core/break.lua) and LuaTex being the closest modern references), [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation and the [TeX hyphenation patterns](https://github.com/hyphenation/tex-hyphen), and [woff-lib](https://github.com/countertype/woff-lib) for optional WOFF2 support. The mesh text pipeline uses [libtess-ts](https://github.com/countertype/libtess-ts) (a port of the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, adaptive curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), and [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/). The vector pipeline uses [Slug](https://github.com/EricLengyel/Slug) by Eric Lengyel for resolution-independent curve rendering
-
 ## Table of contents
 
 - [Overview](#overview)
@@ -41,6 +39,7 @@ Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/h
 - [Browser compatibility](#browser-compatibility)
 - [Testing](#testing)
 - [Build system](#build-system)
+- [Entry points](#entry-points)
 - [Build outputs](#build-outputs)
 - [Acknowledgements](#acknowledgements)
 - [License](#license)
@@ -60,34 +59,14 @@ npm install three
 
 ## Architecture
 
-three-text has a framework-agnostic core that processes fonts and generates geometry data. Lightweight adapters convert this data to framework-specific formats:
-
-- **`three-text`** - Three.js adapter (default export, returns `BufferGeometry`)
-- **`three-text/mesh`** - Same as above (explicit alias)
-- **`three-text/mesh/react`** - React Three Fiber component for extruded mesh text
-- **`three-text/three`** - Deprecated, use `three-text/mesh`
-- **`three-text/three/react`** - Deprecated, use `three-text/mesh/react`
-- **`three-text/mesh/webgl`** - WebGL mesh buffer utility
-- **`three-text/mesh/webgpu`** - WebGPU mesh buffer utility
-- **`three-text/mesh/p5`** - p5.js adapter
-- **`three-text/core`** - Framework-agnostic core (returns raw arrays)
-- **`three-text/vector`** - Vector rendering (Slug per-fragment curve evaluation), `Text.create()` returns a `THREE.Group`
-- **`three-text/vector/react`** - React Three Fiber component for vector text
-- **`three-text/vector/core`** - Framework-agnostic vector core (returns raw `SlugGPUData`, no Three.js dependency)
-- **`three-text/vector/webgl`** - Raw WebGL2 vector renderer (no Three.js dependency)
-- **`three-text/vector/webgpu`** - Raw WebGPU vector renderer (no Three.js dependency)
-- **`three-text/webgl`** - Deprecated, use `three-text/mesh/webgl`
-- **`three-text/webgpu`** - Deprecated, use `three-text/mesh/webgpu`
-- **`three-text/p5`** - Deprecated, use `three-text/mesh/p5`
-
-Most users will just `import { Text } from 'three-text'` for Three.js projects with mesh, or `import { Text } from 'three-text/vector'` for vector text
+three-text has a framework-agnostic core that processes fonts and generates geometry data. Lightweight adapters convert this data to framework-specific formats. Most users will just `import { Text } from 'three-text'` for Three.js projects with mesh, or `import { Text } from 'three-text/vector'` for vector text. See [Entry points](#entry-points) for the full list of adapters
 
 ### Mesh vs vector
 
 The library offers two rendering modes that share the same core (HarfBuzz shaping, Knuth-Plass justification, glyph caching):
 
 - **Mesh** (`three-text` (default) / `three-text/mesh`): triangulated geometry you can extrude, light, and shade. Use for 3D text, text in a scene graph, or anywhere you need depth
-- **Vector** (`three-text/vector`): resolution-independent rendering on the GPU via per-fragment curve evaluation. No tessellation, no stencil buffer. Use for text that needs to stay sharp at arbitrary zoom
+- **Vector** (`three-text/vector`): resolution-independent rendering on the GPU via per-fragment curve evaluation. Use for flat text that needs to stay sharp at arbitrary zoom
 
 Both can be used in the same project from separate entry points
 
@@ -483,6 +462,8 @@ Existing solutions take different approaches:
 
 three-text produces actual geometry from font files, sharper at close distances than bitmap approaches, with control over typesetting and paragraph justification via TeX-based parameters
 
+Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/harfbuzz/harfbuzzjs) (based on [HarfBuzz](https://github.com/harfbuzz/harfbuzz) by Behdad Esfahbod et al) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking (with [SILE](https://github.com/sile-typesetter/sile/blob/master/core/break.lua) and LuaTex being the closest modern references), [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation and the [TeX hyphenation patterns](https://github.com/hyphenation/tex-hyphen), and [woff-lib](https://github.com/countertype/woff-lib) for optional WOFF2 support. The mesh text pipeline uses [libtess-ts](https://github.com/countertype/libtess-ts) (a port of the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, adaptive curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), and [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/). The vector pipeline uses [Slug](https://github.com/EricLengyel/Slug) by Eric Lengyel for resolution-independent curve rendering
+
 ### Why Slug
 
 The vector path uses the Slug algorithm by Eric Lengyel. Each glyph is a single quad; the fragment shader evaluates curve coverage analytically to compute a winding number. Because it operates on winding rather than geometry, it naturally handles the self-intersecting contours that variable fonts produce when axes like weight push outlines into each other
@@ -1256,6 +1237,22 @@ git submodule update --init --recursive
 
 The script then processes the TeX hyphenation data into optimized trie structures. The process is slow for the complete set of languages (~1 minute on an M2 Max), so using `--languages` for development is recommended
 
+## Entry points
+
+- **`three-text`** - Three.js adapter (default export, returns mesh `BufferGeometry`)
+- **`three-text/mesh`** - Same as above (explicit alias)
+- **`three-text/mesh/react`** - React Three Fiber component for extruded mesh text
+- **`three-text/three/react`** - Deprecated, use `three-text/mesh/react`
+- **`three-text/mesh/webgl`** - WebGL mesh buffer utility
+- **`three-text/mesh/webgpu`** - WebGPU mesh buffer utility
+- **`three-text/mesh/p5`** - p5.js adapter
+- **`three-text/core`** - Framework-agnostic core (returns raw arrays)
+- **`three-text/vector`** - Vector rendering (Slug per-fragment curve evaluation), `Text.create()` returns a `THREE.Group`
+- **`three-text/vector/react`** - React Three Fiber component for vector text
+- **`three-text/vector/core`** - Framework-agnostic vector core (returns raw `SlugGPUData`, no Three.js dependency)
+- **`three-text/vector/webgl`** - Raw WebGL2 vector renderer (no Three.js dependency)
+- **`three-text/vector/webgpu`** - Raw WebGPU vector renderer (no Three.js dependency)
+
 ## Build outputs
 
 The build generates multiple module formats for core and all adapters:
@@ -1289,4 +1286,4 @@ The build generates multiple module formats for core and all adapters:
 
 `three-text` was written by Jeremy Tribby ([@jpt](https://github.com/jpt)) and is licensed under the MIT License. See the [LICENSE](LICENSE) file for details
 
-This software includes code from third-party libraries under compatible permissive licenses. For full license details, see the [LICENSE_THIRD_PARTY](LICENSE_THIRD_PARTY) file
+This software includes code from third-party libraries under compatible permissive licenses. For full license details, see the [LICENSE_THIRD_PARTY](LICENSE_THIRD_PARTY) file

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.min.cjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.min.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.umd.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.umd.min.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.1
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/vector/core/index.cjs

@@ -258,7 +258,6 @@ class GlyphOutlineCollector {
 // GPU-ready packed textures + vertex attribute buffers
 const TEX_WIDTH = 4096;
 const LOG_TEX_WIDTH = 12;
-// Float/Uint32 reinterpretation helpers
 const _f32 = new Float32Array(1);
 const _u32 = new Uint32Array(_f32.buffer);
 function uintAsFloat(u) {
@@ -270,9 +269,7 @@ function uintAsFloat(u) {
 function packSlugData(shapes, options) {
     const bandCount = options?.bandCount ?? 16;
     const evenOdd = options?.evenOdd ?? false;
-    // Pack all curves into curveTexture
     const allCurves = [];
-    // Estimate max texels needed
     let totalCurves = 0;
     for (const shape of shapes) {
         totalCurves += shape.curves.length;
@@ -285,13 +282,12 @@ function packSlugData(shapes, options) {
         const entries = [];
         const [ox, oy] = shape.bounds;
         for (const curve of shape.curves) {
-            // Don't let a curve span across row boundary (needs 2 consecutive texels)
             if (curveX >= TEX_WIDTH - 1) {
                 curveX = 0;
                 curveY++;
             }
-            // Store control points in glyph-local space (relative to bounds min)
-            // so the fragment shader's renderCoord subtraction stays near zero
+            // Glyph-local space (relative to bounds min) keeps renderCoord
+            // subtraction near zero, preserving float32 precision in the solver
             const lp1x = curve.p1[0] - ox, lp1y = curve.p1[1] - oy;
             const lp2x = curve.p2[0] - ox, lp2y = curve.p2[1] - oy;
             const lp3x = curve.p3[0] - ox, lp3y = curve.p3[1] - oy;
@@ -320,12 +316,10 @@ function packSlugData(shapes, options) {
         allCurves.push(entries);
     }
     const actualCurveTexHeight = curveY + 1;
-    // Build band data for each shape and pack into bandTexture
-    // Layout per shape in bandTexture (relative to glyphLoc):
-    //   [0 .. hBandMax]                          : h-band headers
-    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
-    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
-    // First pass: compute total band texels needed
+    // Band texture layout per shape (relative to glyphLoc):
+    //   [0 .. hBandMax]                     h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax] v-band headers
+    //   [hBandMax+vBandMax+2 .. ]           curve index lists
     const shapeBandData = [];
     let totalBandTexels = 0;
     for (let si = 0; si < shapes.length; si++) {
@@ -345,21 +339,19 @@ function packSlugData(shapes, options) {
         const vBandCount = Math.min(bandCount, 255);
         const bandMaxY = hBandCount - 1;
         const bandMaxX = vBandCount - 1;
-        // Build horizontal bands (partition y-axis, glyph-local coords)
+        // Horizontal bands (partition y-axis)
         const hBands = [];
         const hLists = [];
         const bandH = h / hBandCount;
         for (let bi = 0; bi < hBandCount; bi++) {
             const bandMinY = bi * bandH;
             const bandMaxYCoord = bandMinY + bandH;
-            // Collect curves whose y-range overlaps this band
             const list = [];
             for (const c of curves) {
                 if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
                     list.push({ curve: c, sortKey: c.maxX });
                 }
             }
-            // Sort by descending max-x for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -368,7 +360,7 @@ function packSlugData(shapes, options) {
             hBands.push({ curveCount: list.length, listOffset: 0 });
             hLists.push(flatList);
         }
-        // Build vertical bands (partition x-axis, glyph-local coords)
+        // Vertical bands (partition x-axis)
         const vBands = [];
         const vLists = [];
         const bandW = w / vBandCount;
@@ -381,7 +373,6 @@ function packSlugData(shapes, options) {
                     list.push({ curve: c, sortKey: c.maxY });
                 }
             }
-            // Sort by descending max-y for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -390,7 +381,6 @@ function packSlugData(shapes, options) {
             vBands.push({ curveCount: list.length, listOffset: 0 });
             vLists.push(flatList);
         }
-        // Total texels for this shape: band headers + curve lists
         const headerTexels = hBandCount + vBandCount;
         let listTexels = 0;
         for (const l of hLists)
@@ -404,10 +394,8 @@ function packSlugData(shapes, options) {
         });
         totalBandTexels += total;
     }
-    // Allocate bandTexture (extra rows for row-alignment padding of curve lists)
     const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length * 2);
     const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
-    // Pack band data per shape
     let bandX = 0;
     let bandY = 0;
     const glyphLocs = [];
@@ -417,11 +405,8 @@ function packSlugData(shapes, options) {
             glyphLocs.push({ x: 0, y: 0 });
             continue;
         }
-        // Ensure glyph data doesn't start too close to row end
-        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
-        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
-        // must be reachable. CalcBandLoc handles wrapping for curve lists.
-        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        // Band headers are read without CalcBandLoc wrapping, so all
+        // headers for a glyph must fit within a single texture row
         const minContiguous = sd.hBands.length + sd.vBands.length;
         if (bandX + minContiguous > TEX_WIDTH) {
             bandX = 0;
@@ -430,11 +415,8 @@ function packSlugData(shapes, options) {
         const glyphLocX = bandX;
         const glyphLocY = bandY;
         glyphLocs.push({ x: glyphLocX, y: glyphLocY });
-        // Curve lists start after all headers
         let listStartOffset = sd.hBands.length + sd.vBands.length;
-        // The shader reads curve list entries at (hbandLoc.x + curveIndex, hbandLoc.y)
-        // with NO row wrapping. Each list must fit entirely within a single texture row.
-        // Pad the offset to the next row start when a list would cross a row boundary.
+        // Curve lists aren't row-wrapped by the shader, so pad to avoid crossing
         const ensureListFits = (listLen) => {
             if (listLen === 0)
                 return;
@@ -443,21 +425,18 @@ function packSlugData(shapes, options) {
                 listStartOffset += (TEX_WIDTH - startX);
             }
         };
-        // Assign list offsets for h-bands
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const listLen = sd.hLists[bi].length / 2;
             ensureListFits(listLen);
             sd.hBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Assign list offsets for v-bands
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const listLen = sd.vLists[bi].length / 2;
             ensureListFits(listLen);
             sd.vBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Write h-band headers
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const tx = glyphLocX + bi;
             const ty = glyphLocY;
@@ -467,7 +446,6 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write v-band headers (after h-bands)
         const vBandStart = glyphLocX + sd.hBands.length;
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const tx = vBandStart + bi;
@@ -478,9 +456,7 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write curve lists using CalcBandLoc-style wrapping
         const texWidthMask = (1 << LOG_TEX_WIDTH) - 1;
-        // Write h-band curve lists
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const list = sd.hLists[bi];
             const baseOffset = sd.hBands[bi].listOffset;
@@ -489,13 +465,12 @@ function packSlugData(shapes, options) {
                 const by = glyphLocY + (bx >> LOG_TEX_WIDTH);
                 bx &= texWidthMask;
                 const idx = (by * TEX_WIDTH + bx) * 4;
-                bandData[idx + 0] = list[ci]; // curveTexX
-                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
                 bandData[idx + 2] = 0;
                 bandData[idx + 3] = 0;
             }
         }
-        // Write v-band curve lists
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const list = sd.vLists[bi];
             const baseOffset = sd.vBands[bi].listOffset;
@@ -510,24 +485,20 @@ function packSlugData(shapes, options) {
                 bandData[idx + 3] = 0;
             }
         }
-        // Advance band cursor past this shape's data
         let endBx = glyphLocX + listStartOffset;
         bandY = glyphLocY + (endBx >> LOG_TEX_WIDTH);
         bandX = endBx & texWidthMask;
     }
     const actualBandTexHeight = bandY + 1;
-    // Build vertex attributes
-    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
     const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
     const VERTS_PER_SHAPE = 4;
     const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
     const indices = new Uint16Array(shapes.length * 6);
-    // Corner normals (outward-pointing, un-normalized; SlugDilate normalizes)
     const cornerNormals = [
-        [-1, -1], // bottom-left
-        [1, -1], // bottom-right
-        [1, 1], // top-right
-        [-1, 1], // top-left
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1],
     ];
     for (let si = 0; si < shapes.length; si++) {
         const shape = shapes[si];
@@ -536,28 +507,23 @@ function packSlugData(shapes, options) {
         const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
         const w = bMaxX - bMinX;
         const h = bMaxY - bMinY;
-        // Corner positions in object-space
         const corners = [
             [bMinX, bMinY],
             [bMaxX, bMinY],
             [bMaxX, bMaxY],
             [bMinX, bMaxY],
         ];
-        // Em-space sample coords in glyph-local space (origin at bounds min)
         const emCorners = [
             [0, 0],
             [w, 0],
             [w, h],
             [0, h],
         ];
-        // Pack tex.z: glyph location in band texture
         const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
-        // Pack tex.w: band max + flags
         let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
         if (evenOdd)
             texWBits |= 0x10000000; // E flag at bit 28
         const texW = uintAsFloat(texWBits);
-        // Band transform: scale to map glyph-local em-coords to band indices
         const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
         const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
         for (let vi = 0; vi < 4; vi++) {
@@ -572,23 +538,22 @@ function packSlugData(shapes, options) {
             vertices[base + 5] = emCorners[vi][1];
             vertices[base + 6] = texZ;
             vertices[base + 7] = texW;
-            // jac: identity Jacobian (em-space is a pure translation of object-space)
+            // jac: identity (em-space is a translation of object-space)
             vertices[base + 8] = 1.0;
             vertices[base + 9] = 0.0;
             vertices[base + 10] = 0.0;
             vertices[base + 11] = 1.0;
-            // bnd: band scale (offset is zero in glyph-local space)
+            // bnd: band scale (offset zero in glyph-local space)
             vertices[base + 12] = bandScaleX;
             vertices[base + 13] = bandScaleY;
             vertices[base + 14] = 0;
             vertices[base + 15] = 0;
-            // col: white with full alpha (caller overrides via uniform or attribute)
+            // col
             vertices[base + 16] = 1.0;
             vertices[base + 17] = 1.0;
             vertices[base + 18] = 1.0;
             vertices[base + 19] = 1.0;
         }
-        // Indices: two triangles per quad
         const vBase = si * 4;
         const iBase = si * 6;
         indices[iBase + 0] = vBase + 0;
@@ -797,7 +762,6 @@ function computePlaneBounds(glyphInfos) {
     }
     return { min: { x: minX, y: minY, z: 0 }, max: { x: maxX, y: maxY, z: 0 } };
 }
-// Public API
 function buildVectorResult(layoutHandle, ctx, options) {
     const scale = layoutHandle.layoutData.pixelsPerFontUnit;
     let cachedQuery = null;

package/dist/vector/core/index.js

@@ -256,7 +256,6 @@ class GlyphOutlineCollector {
 // GPU-ready packed textures + vertex attribute buffers
 const TEX_WIDTH = 4096;
 const LOG_TEX_WIDTH = 12;
-// Float/Uint32 reinterpretation helpers
 const _f32 = new Float32Array(1);
 const _u32 = new Uint32Array(_f32.buffer);
 function uintAsFloat(u) {
@@ -268,9 +267,7 @@ function uintAsFloat(u) {
 function packSlugData(shapes, options) {
     const bandCount = options?.bandCount ?? 16;
     const evenOdd = options?.evenOdd ?? false;
-    // Pack all curves into curveTexture
     const allCurves = [];
-    // Estimate max texels needed
     let totalCurves = 0;
     for (const shape of shapes) {
         totalCurves += shape.curves.length;
@@ -283,13 +280,12 @@ function packSlugData(shapes, options) {
         const entries = [];
         const [ox, oy] = shape.bounds;
         for (const curve of shape.curves) {
-            // Don't let a curve span across row boundary (needs 2 consecutive texels)
             if (curveX >= TEX_WIDTH - 1) {
                 curveX = 0;
                 curveY++;
             }
-            // Store control points in glyph-local space (relative to bounds min)
-            // so the fragment shader's renderCoord subtraction stays near zero
+            // Glyph-local space (relative to bounds min) keeps renderCoord
+            // subtraction near zero, preserving float32 precision in the solver
             const lp1x = curve.p1[0] - ox, lp1y = curve.p1[1] - oy;
             const lp2x = curve.p2[0] - ox, lp2y = curve.p2[1] - oy;
             const lp3x = curve.p3[0] - ox, lp3y = curve.p3[1] - oy;
@@ -318,12 +314,10 @@ function packSlugData(shapes, options) {
         allCurves.push(entries);
     }
     const actualCurveTexHeight = curveY + 1;
-    // Build band data for each shape and pack into bandTexture
-    // Layout per shape in bandTexture (relative to glyphLoc):
-    //   [0 .. hBandMax]                          : h-band headers
-    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
-    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
-    // First pass: compute total band texels needed
+    // Band texture layout per shape (relative to glyphLoc):
+    //   [0 .. hBandMax]                     h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax] v-band headers
+    //   [hBandMax+vBandMax+2 .. ]           curve index lists
     const shapeBandData = [];
     let totalBandTexels = 0;
     for (let si = 0; si < shapes.length; si++) {
@@ -343,21 +337,19 @@ function packSlugData(shapes, options) {
         const vBandCount = Math.min(bandCount, 255);
         const bandMaxY = hBandCount - 1;
         const bandMaxX = vBandCount - 1;
-        // Build horizontal bands (partition y-axis, glyph-local coords)
+        // Horizontal bands (partition y-axis)
         const hBands = [];
         const hLists = [];
         const bandH = h / hBandCount;
         for (let bi = 0; bi < hBandCount; bi++) {
             const bandMinY = bi * bandH;
             const bandMaxYCoord = bandMinY + bandH;
-            // Collect curves whose y-range overlaps this band
             const list = [];
             for (const c of curves) {
                 if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
                     list.push({ curve: c, sortKey: c.maxX });
                 }
             }
-            // Sort by descending max-x for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -366,7 +358,7 @@ function packSlugData(shapes, options) {
             hBands.push({ curveCount: list.length, listOffset: 0 });
             hLists.push(flatList);
         }
-        // Build vertical bands (partition x-axis, glyph-local coords)
+        // Vertical bands (partition x-axis)
         const vBands = [];
         const vLists = [];
         const bandW = w / vBandCount;
@@ -379,7 +371,6 @@ function packSlugData(shapes, options) {
                     list.push({ curve: c, sortKey: c.maxY });
                 }
             }
-            // Sort by descending max-y for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -388,7 +379,6 @@ function packSlugData(shapes, options) {
             vBands.push({ curveCount: list.length, listOffset: 0 });
             vLists.push(flatList);
         }
-        // Total texels for this shape: band headers + curve lists
         const headerTexels = hBandCount + vBandCount;
         let listTexels = 0;
         for (const l of hLists)
@@ -402,10 +392,8 @@ function packSlugData(shapes, options) {
         });
         totalBandTexels += total;
     }
-    // Allocate bandTexture (extra rows for row-alignment padding of curve lists)
     const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length * 2);
     const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
-    // Pack band data per shape
     let bandX = 0;
     let bandY = 0;
     const glyphLocs = [];
@@ -415,11 +403,8 @@ function packSlugData(shapes, options) {
             glyphLocs.push({ x: 0, y: 0 });
             continue;
         }
-        // Ensure glyph data doesn't start too close to row end
-        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
-        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
-        // must be reachable. CalcBandLoc handles wrapping for curve lists.
-        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        // Band headers are read without CalcBandLoc wrapping, so all
+        // headers for a glyph must fit within a single texture row
         const minContiguous = sd.hBands.length + sd.vBands.length;
         if (bandX + minContiguous > TEX_WIDTH) {
             bandX = 0;
@@ -428,11 +413,8 @@ function packSlugData(shapes, options) {
         const glyphLocX = bandX;
         const glyphLocY = bandY;
         glyphLocs.push({ x: glyphLocX, y: glyphLocY });
-        // Curve lists start after all headers
         let listStartOffset = sd.hBands.length + sd.vBands.length;
-        // The shader reads curve list entries at (hbandLoc.x + curveIndex, hbandLoc.y)
-        // with NO row wrapping. Each list must fit entirely within a single texture row.
-        // Pad the offset to the next row start when a list would cross a row boundary.
+        // Curve lists aren't row-wrapped by the shader, so pad to avoid crossing
         const ensureListFits = (listLen) => {
             if (listLen === 0)
                 return;
@@ -441,21 +423,18 @@ function packSlugData(shapes, options) {
                 listStartOffset += (TEX_WIDTH - startX);
             }
         };
-        // Assign list offsets for h-bands
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const listLen = sd.hLists[bi].length / 2;
             ensureListFits(listLen);
             sd.hBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Assign list offsets for v-bands
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const listLen = sd.vLists[bi].length / 2;
             ensureListFits(listLen);
             sd.vBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Write h-band headers
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const tx = glyphLocX + bi;
             const ty = glyphLocY;
@@ -465,7 +444,6 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write v-band headers (after h-bands)
         const vBandStart = glyphLocX + sd.hBands.length;
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const tx = vBandStart + bi;
@@ -476,9 +454,7 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write curve lists using CalcBandLoc-style wrapping
         const texWidthMask = (1 << LOG_TEX_WIDTH) - 1;
-        // Write h-band curve lists
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const list = sd.hLists[bi];
             const baseOffset = sd.hBands[bi].listOffset;
@@ -487,13 +463,12 @@ function packSlugData(shapes, options) {
                 const by = glyphLocY + (bx >> LOG_TEX_WIDTH);
                 bx &= texWidthMask;
                 const idx = (by * TEX_WIDTH + bx) * 4;
-                bandData[idx + 0] = list[ci]; // curveTexX
-                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
                 bandData[idx + 2] = 0;
                 bandData[idx + 3] = 0;
             }
         }
-        // Write v-band curve lists
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const list = sd.vLists[bi];
             const baseOffset = sd.vBands[bi].listOffset;
@@ -508,24 +483,20 @@ function packSlugData(shapes, options) {
                 bandData[idx + 3] = 0;
             }
         }
-        // Advance band cursor past this shape's data
         let endBx = glyphLocX + listStartOffset;
         bandY = glyphLocY + (endBx >> LOG_TEX_WIDTH);
         bandX = endBx & texWidthMask;
     }
     const actualBandTexHeight = bandY + 1;
-    // Build vertex attributes
-    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
     const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
     const VERTS_PER_SHAPE = 4;
     const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
     const indices = new Uint16Array(shapes.length * 6);
-    // Corner normals (outward-pointing, un-normalized; SlugDilate normalizes)
     const cornerNormals = [
-        [-1, -1], // bottom-left
-        [1, -1], // bottom-right
-        [1, 1], // top-right
-        [-1, 1], // top-left
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1],
     ];
     for (let si = 0; si < shapes.length; si++) {
         const shape = shapes[si];
@@ -534,28 +505,23 @@ function packSlugData(shapes, options) {
         const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
         const w = bMaxX - bMinX;
         const h = bMaxY - bMinY;
-        // Corner positions in object-space
         const corners = [
             [bMinX, bMinY],
             [bMaxX, bMinY],
             [bMaxX, bMaxY],
             [bMinX, bMaxY],
         ];
-        // Em-space sample coords in glyph-local space (origin at bounds min)
         const emCorners = [
             [0, 0],
             [w, 0],
             [w, h],
             [0, h],
         ];
-        // Pack tex.z: glyph location in band texture
         const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
-        // Pack tex.w: band max + flags
         let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
         if (evenOdd)
             texWBits |= 0x10000000; // E flag at bit 28
         const texW = uintAsFloat(texWBits);
-        // Band transform: scale to map glyph-local em-coords to band indices
         const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
         const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
         for (let vi = 0; vi < 4; vi++) {
@@ -570,23 +536,22 @@ function packSlugData(shapes, options) {
             vertices[base + 5] = emCorners[vi][1];
             vertices[base + 6] = texZ;
             vertices[base + 7] = texW;
-            // jac: identity Jacobian (em-space is a pure translation of object-space)
+            // jac: identity (em-space is a translation of object-space)
             vertices[base + 8] = 1.0;
             vertices[base + 9] = 0.0;
             vertices[base + 10] = 0.0;
             vertices[base + 11] = 1.0;
-            // bnd: band scale (offset is zero in glyph-local space)
+            // bnd: band scale (offset zero in glyph-local space)
             vertices[base + 12] = bandScaleX;
             vertices[base + 13] = bandScaleY;
             vertices[base + 14] = 0;
             vertices[base + 15] = 0;
-            // col: white with full alpha (caller overrides via uniform or attribute)
+            // col
             vertices[base + 16] = 1.0;
             vertices[base + 17] = 1.0;
             vertices[base + 18] = 1.0;
             vertices[base + 19] = 1.0;
         }
-        // Indices: two triangles per quad
         const vBase = si * 4;
         const iBase = si * 6;
         indices[iBase + 0] = vBase + 0;
@@ -795,7 +760,6 @@ function computePlaneBounds(glyphInfos) {
     }
     return { min: { x: minX, y: minY, z: 0 }, max: { x: maxX, y: maxY, z: 0 } };
 }
-// Public API
 function buildVectorResult(layoutHandle, ctx, options) {
     const scale = layoutHandle.layoutData.pixelsPerFontUnit;
     let cachedQuery = null;

package/dist/vector/index2.cjs

@@ -22,8 +22,6 @@ function _interopNamespaceDefault(e) {
 
 var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
 
-// Restructures the tightly-packed vertex buffer from SlugPacker into
-// separate per-attribute arrays for GPU attribute binding
 const FLOATS_PER_VERT = 20;
 function unpackSlugVertices(gpuData) {
     const vertCount = gpuData.shapeCount * 4;
@@ -45,7 +43,6 @@ function unpackSlugVertices(gpuData) {
         bandings[i * 4 + 1] = srcF[s + 13];
         bandings[i * 4 + 2] = srcF[s + 14];
         bandings[i * 4 + 3] = srcF[s + 15];
-        // Unpack glyph location and band metadata from bit-packed fields
         const g0 = srcU[s + 6];
         const g1 = srcU[s + 7];
         glyphData[i * 4] = g0 & 0xFFFF;
@@ -57,7 +54,6 @@ function unpackSlugVertices(gpuData) {
         colors[i * 4 + 2] = srcF[s + 18];
         colors[i * 4 + 3] = srcF[s + 19];
     }
-    // Per-glyph center: average of quad corner positions
     const glyphCenters = new Float32Array(vertCount * 3);
     const glyphIndices = new Float32Array(vertCount);
     for (let g = 0; g < gpuData.shapeCount; g++) {
@@ -82,23 +78,14 @@ function unpackSlugVertices(gpuData) {
 
 var fragGLSL = "#version 300 es\n// GLSL 300 es port of the Slug fragment shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n#define kLogBandTextureWidth 12\n\nin vec4 v_color;\nin vec2 v_texcoord;\nflat in vec4 v_banding;\nflat in ivec4 v_glyph;\n\nuniform sampler2D curveTexture;     // RGBA32F control points\nuniform highp usampler2D bandTexture; // RGBA32UI band data\n\nlayout(location = 0) out vec4 outColor;\n\nuint CalcRootCode(float y1, float y2, float y3) {\n    uint i1 = floatBitsToUint(y1) >> 31u;\n    uint i2 = floatBitsToUint(y2) >> 30u;\n    uint i3 = floatBitsToUint(y3) >> 29u;\n\n    uint shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nvec2 SolveHorizPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.y;\n    float rb = 0.5 / b.y;\n\n    float d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    float t1 = (b.y - d) * ra;\n    float t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) t1 = t2 = p12.y * rb;\n\n    return vec2((a.x * t1 - b.x * 2.0) * t1 + p12.x, (a.x * t2 - b.x * 2.0) * t2 + p12.x);\n}\n\nvec2 SolveVertPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.x;\n    float rb = 0.5 / b.x;\n\n    float d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    float t1 = (b.x - d) * ra;\n    float t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) t1 = t2 = p12.x * rb;\n\n    return vec2((a.y * t1 - b.y * 2.0) * t1 + p12.y, (a.y * t2 - b.y * 2.0) * t2 + p12.y);\n}\n\nivec2 CalcBandLoc(ivec2 glyphLoc, uint offset) {\n    ivec2 bandLoc = ivec2(glyphLoc.x + int(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> kLogBandTextureWidth;\n    bandLoc.x &= (1 << kLogBandTextureWidth) - 1;\n    return bandLoc;\n}\n\nfloat CalcCoverage(float xcov, float ycov, float xwgt, float ywgt, int flags) {\n    float coverage = max(abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0), min(abs(xcov), abs(ycov)));\n\n#if defined(SLUG_EVENODD)\n    if ((flags & 0x1000) == 0) {\n#endif\n        coverage = clamp(coverage, 0.0, 1.0);\n#if defined(SLUG_EVENODD)\n    } else {\n        coverage = 1.0 - abs(1.0 - fract(coverage * 0.5) * 2.0);\n    }\n#endif\n\n#if defined(SLUG_WEIGHT)\n    coverage = sqrt(coverage);\n#endif\n\n    return coverage;\n}\n\nfloat SlugRenderSingle(vec2 renderCoord, vec2 emsPerPixel, vec4 bandTransform, ivec4 glyphData) {\n    int curveIndex;\n\n    vec2 pixelsPerEm = 1.0 / emsPerPixel;\n\n    ivec2 bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    ivec2 bandIndex = clamp(ivec2(renderCoord * bandTransform.xy + bandTransform.zw), ivec2(0, 0), bandMax);\n    ivec2 glyphLoc = glyphData.xy;\n\n    float xcov = 0.0;\n    float xwgt = 0.0;\n\n    uvec2 hbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    ivec2 hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(hbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(hbandLoc.x + curveIndex, hbandLoc.y), 0).xy);\n\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break;\n\n        uint code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            vec2 r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    float ycov = 0.0;\n    float ywgt = 0.0;\n\n    uvec2 vbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    ivec2 vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(vbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(vbandLoc.x + curveIndex, vbandLoc.y), 0).xy);\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break;\n\n        uint code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            vec2 r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt, glyphData.w);\n}\n\nfloat SlugRender(vec2 renderCoord, vec4 bandTransform, ivec4 glyphData) {\n    vec2 emsPerPixel = fwidth(renderCoord);\n\n#if defined(SLUG_ADAPTIVE_SUPERSAMPLE)\n    // Per-pixel rotated RGSS-4.  The base RGSS offsets are rotated by a\n    // unique angle per fragment (interleaved gradient noise).  This converts\n    // structured aliasing shimmer into uncorrelated grain that the eye\n    // naturally filters out, much closer to how hardware MSAA on many small\n    // triangles behaves perceptually.\n    float noise = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n    float angle = noise * 6.2831853;\n    float ca = cos(angle), sa = sin(angle);\n\n    // Base RGSS offsets rotated by per-pixel angle\n    vec2 o0 = vec2(ca * -0.375 - sa *  0.125, sa * -0.375 + ca *  0.125) * emsPerPixel;\n    vec2 o1 = vec2(ca *  0.125 - sa *  0.375, sa *  0.125 + ca *  0.375) * emsPerPixel;\n    vec2 o2 = vec2(ca *  0.375 - sa * -0.125, sa *  0.375 + ca * -0.125) * emsPerPixel;\n    vec2 o3 = vec2(ca * -0.125 - sa * -0.375, sa * -0.125 + ca * -0.375) * emsPerPixel;\n\n    float coverage =\n        SlugRenderSingle(renderCoord + o0, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o1, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o2, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o3, emsPerPixel, bandTransform, glyphData);\n    return coverage * 0.25;\n#else\n    return SlugRenderSingle(renderCoord, emsPerPixel, bandTransform, glyphData);\n#endif\n}\n\nvoid main() {\n    float coverage = SlugRender(v_texcoord, v_banding, v_glyph);\n    outColor = v_color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const fragmentShaderGLSL300 = fragGLSL;
 
-// Slug GLSL adapter for Three.js, using RawShaderMaterial with the
-// reference GLSL shaders. Works with both WebGLRenderer and
-// WebGPURenderer (via GLSL-to-WGSL transpilation)
+// Slug adapter using Three.js RawShaderMaterial (GLSL)
+// Works with any Three.js renderer (WebGL or WebGPU via transpilation)
 //
-// Compared to the TSL adapter (slugTSL.ts):
-//   - Works with any Three.js renderer (no node-material dependency)
-//   - Uses native Uint32 band texture (no float conversion)
-//   - Supports GLSL animation injection via animationDeclarations/animationBody
-//   - Same tradeoff: no vertex dilation (may cause sub-pixel edge clipping at extreme zoom)
-//
-// Requires peer dependency: three
+// Supports GLSL animation injection and native Uint32 band textures
+// No vertex dilation; may clip at sub-pixel edges under extreme zoom
 // @ts-ignore - three is a peer dependency
 // Three.js GLSL3 mode prepends #version 300 es, so strip it from the raw shader
 const fragShader = fragmentShaderGLSL300.replace(/^#version\s+300\s+es\s*\n/, '');
@@ -149,13 +136,12 @@ function createSlugGLSLMesh(gpuData, options) {
     geo.setAttribute('glyphCenter', new THREE__namespace.Float32BufferAttribute(attrs.glyphCenters, 3));
     geo.setAttribute('glyphIndex', new THREE__namespace.Float32BufferAttribute(attrs.glyphIndices, 1));
     geo.setIndex(new THREE__namespace.BufferAttribute(gpuData.indices, 1));
-    // Curve texture: RGBA32F
     const curveTex = new THREE__namespace.DataTexture(gpuData.curveTexture.data, gpuData.curveTexture.width, gpuData.curveTexture.height, THREE__namespace.RGBAFormat, THREE__namespace.FloatType);
     curveTex.minFilter = THREE__namespace.NearestFilter;
     curveTex.magFilter = THREE__namespace.NearestFilter;
     curveTex.generateMipmaps = false;
     curveTex.needsUpdate = true;
-    // Band texture: native RGBA32UI (no float conversion needed)
+    // RGBA32UI (unlike TSL, GLSL supports integer textures natively)
     const bandTex = new THREE__namespace.DataTexture(gpuData.bandTexture.data, gpuData.bandTexture.width, gpuData.bandTexture.height);
     bandTex.format = THREE__namespace.RGBAIntegerFormat;
     bandTex.type = THREE__namespace.UnsignedIntType;

package/dist/vector/index2.js

@@ -1,8 +1,6 @@
 import { Text as Text$1 } from './core/index.js';
 import * as THREE from 'three';
 
-// Restructures the tightly-packed vertex buffer from SlugPacker into
-// separate per-attribute arrays for GPU attribute binding
 const FLOATS_PER_VERT = 20;
 function unpackSlugVertices(gpuData) {
     const vertCount = gpuData.shapeCount * 4;
@@ -24,7 +22,6 @@ function unpackSlugVertices(gpuData) {
         bandings[i * 4 + 1] = srcF[s + 13];
         bandings[i * 4 + 2] = srcF[s + 14];
         bandings[i * 4 + 3] = srcF[s + 15];
-        // Unpack glyph location and band metadata from bit-packed fields
         const g0 = srcU[s + 6];
         const g1 = srcU[s + 7];
         glyphData[i * 4] = g0 & 0xFFFF;
@@ -36,7 +33,6 @@ function unpackSlugVertices(gpuData) {
         colors[i * 4 + 2] = srcF[s + 18];
         colors[i * 4 + 3] = srcF[s + 19];
     }
-    // Per-glyph center: average of quad corner positions
     const glyphCenters = new Float32Array(vertCount * 3);
     const glyphIndices = new Float32Array(vertCount);
     for (let g = 0; g < gpuData.shapeCount; g++) {
@@ -61,23 +57,14 @@ function unpackSlugVertices(gpuData) {
 
 var fragGLSL = "#version 300 es\n// GLSL 300 es port of the Slug fragment shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n#define kLogBandTextureWidth 12\n\nin vec4 v_color;\nin vec2 v_texcoord;\nflat in vec4 v_banding;\nflat in ivec4 v_glyph;\n\nuniform sampler2D curveTexture;     // RGBA32F control points\nuniform highp usampler2D bandTexture; // RGBA32UI band data\n\nlayout(location = 0) out vec4 outColor;\n\nuint CalcRootCode(float y1, float y2, float y3) {\n    uint i1 = floatBitsToUint(y1) >> 31u;\n    uint i2 = floatBitsToUint(y2) >> 30u;\n    uint i3 = floatBitsToUint(y3) >> 29u;\n\n    uint shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nvec2 SolveHorizPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.y;\n    float rb = 0.5 / b.y;\n\n    float d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    float t1 = (b.y - d) * ra;\n    float t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) t1 = t2 = p12.y * rb;\n\n    return vec2((a.x * t1 - b.x * 2.0) * t1 + p12.x, (a.x * t2 - b.x * 2.0) * t2 + p12.x);\n}\n\nvec2 SolveVertPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.x;\n    float rb = 0.5 / b.x;\n\n    float d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    float t1 = (b.x - d) * ra;\n    float t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) t1 = t2 = p12.x * rb;\n\n    return vec2((a.y * t1 - b.y * 2.0) * t1 + p12.y, (a.y * t2 - b.y * 2.0) * t2 + p12.y);\n}\n\nivec2 CalcBandLoc(ivec2 glyphLoc, uint offset) {\n    ivec2 bandLoc = ivec2(glyphLoc.x + int(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> kLogBandTextureWidth;\n    bandLoc.x &= (1 << kLogBandTextureWidth) - 1;\n    return bandLoc;\n}\n\nfloat CalcCoverage(float xcov, float ycov, float xwgt, float ywgt, int flags) {\n    float coverage = max(abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0), min(abs(xcov), abs(ycov)));\n\n#if defined(SLUG_EVENODD)\n    if ((flags & 0x1000) == 0) {\n#endif\n        coverage = clamp(coverage, 0.0, 1.0);\n#if defined(SLUG_EVENODD)\n    } else {\n        coverage = 1.0 - abs(1.0 - fract(coverage * 0.5) * 2.0);\n    }\n#endif\n\n#if defined(SLUG_WEIGHT)\n    coverage = sqrt(coverage);\n#endif\n\n    return coverage;\n}\n\nfloat SlugRenderSingle(vec2 renderCoord, vec2 emsPerPixel, vec4 bandTransform, ivec4 glyphData) {\n    int curveIndex;\n\n    vec2 pixelsPerEm = 1.0 / emsPerPixel;\n\n    ivec2 bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    ivec2 bandIndex = clamp(ivec2(renderCoord * bandTransform.xy + bandTransform.zw), ivec2(0, 0), bandMax);\n    ivec2 glyphLoc = glyphData.xy;\n\n    float xcov = 0.0;\n    float xwgt = 0.0;\n\n    uvec2 hbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    ivec2 hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(hbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(hbandLoc.x + curveIndex, hbandLoc.y), 0).xy);\n\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break;\n\n        uint code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            vec2 r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    float ycov = 0.0;\n    float ywgt = 0.0;\n\n    uvec2 vbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    ivec2 vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(vbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(vbandLoc.x + curveIndex, vbandLoc.y), 0).xy);\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break;\n\n        uint code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            vec2 r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt, glyphData.w);\n}\n\nfloat SlugRender(vec2 renderCoord, vec4 bandTransform, ivec4 glyphData) {\n    vec2 emsPerPixel = fwidth(renderCoord);\n\n#if defined(SLUG_ADAPTIVE_SUPERSAMPLE)\n    // Per-pixel rotated RGSS-4.  The base RGSS offsets are rotated by a\n    // unique angle per fragment (interleaved gradient noise).  This converts\n    // structured aliasing shimmer into uncorrelated grain that the eye\n    // naturally filters out, much closer to how hardware MSAA on many small\n    // triangles behaves perceptually.\n    float noise = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n    float angle = noise * 6.2831853;\n    float ca = cos(angle), sa = sin(angle);\n\n    // Base RGSS offsets rotated by per-pixel angle\n    vec2 o0 = vec2(ca * -0.375 - sa *  0.125, sa * -0.375 + ca *  0.125) * emsPerPixel;\n    vec2 o1 = vec2(ca *  0.125 - sa *  0.375, sa *  0.125 + ca *  0.375) * emsPerPixel;\n    vec2 o2 = vec2(ca *  0.375 - sa * -0.125, sa *  0.375 + ca * -0.125) * emsPerPixel;\n    vec2 o3 = vec2(ca * -0.125 - sa * -0.375, sa * -0.125 + ca * -0.375) * emsPerPixel;\n\n    float coverage =\n        SlugRenderSingle(renderCoord + o0, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o1, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o2, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o3, emsPerPixel, bandTransform, glyphData);\n    return coverage * 0.25;\n#else\n    return SlugRenderSingle(renderCoord, emsPerPixel, bandTransform, glyphData);\n#endif\n}\n\nvoid main() {\n    float coverage = SlugRender(v_texcoord, v_banding, v_glyph);\n    outColor = v_color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const fragmentShaderGLSL300 = fragGLSL;
 
-// Slug GLSL adapter for Three.js, using RawShaderMaterial with the
-// reference GLSL shaders. Works with both WebGLRenderer and
-// WebGPURenderer (via GLSL-to-WGSL transpilation)
+// Slug adapter using Three.js RawShaderMaterial (GLSL)
+// Works with any Three.js renderer (WebGL or WebGPU via transpilation)
 //
-// Compared to the TSL adapter (slugTSL.ts):
-//   - Works with any Three.js renderer (no node-material dependency)
-//   - Uses native Uint32 band texture (no float conversion)
-//   - Supports GLSL animation injection via animationDeclarations/animationBody
-//   - Same tradeoff: no vertex dilation (may cause sub-pixel edge clipping at extreme zoom)
-//
-// Requires peer dependency: three
+// Supports GLSL animation injection and native Uint32 band textures
+// No vertex dilation; may clip at sub-pixel edges under extreme zoom
 // @ts-ignore - three is a peer dependency
 // Three.js GLSL3 mode prepends #version 300 es, so strip it from the raw shader
 const fragShader = fragmentShaderGLSL300.replace(/^#version\s+300\s+es\s*\n/, '');
@@ -128,13 +115,12 @@ function createSlugGLSLMesh(gpuData, options) {
     geo.setAttribute('glyphCenter', new THREE.Float32BufferAttribute(attrs.glyphCenters, 3));
     geo.setAttribute('glyphIndex', new THREE.Float32BufferAttribute(attrs.glyphIndices, 1));
     geo.setIndex(new THREE.BufferAttribute(gpuData.indices, 1));
-    // Curve texture: RGBA32F
     const curveTex = new THREE.DataTexture(gpuData.curveTexture.data, gpuData.curveTexture.width, gpuData.curveTexture.height, THREE.RGBAFormat, THREE.FloatType);
     curveTex.minFilter = THREE.NearestFilter;
     curveTex.magFilter = THREE.NearestFilter;
     curveTex.generateMipmaps = false;
     curveTex.needsUpdate = true;
-    // Band texture: native RGBA32UI (no float conversion needed)
+    // RGBA32UI (unlike TSL, GLSL supports integer textures natively)
     const bandTex = new THREE.DataTexture(gpuData.bandTexture.data, gpuData.bandTexture.width, gpuData.bandTexture.height);
     bandTex.format = THREE.RGBAIntegerFormat;
     bandTex.type = THREE.UnsignedIntType;

package/dist/vector/slugTSL.cjs

@@ -25,20 +25,11 @@ function _interopNamespaceDefault(e) {
 
 var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
 
-// Slug TSL adapter for Three.js WebGPURenderer (and WebGL via r170+)
+// Slug adapter using Three.js TSL (node materials)
+// Works on both WebGPU and WebGL backends (r170+)
 //
-// Creates a single Three.js Mesh with a NodeMaterial that implements
-// the Slug algorithm: per-fragment winding number evaluation via
-// band-accelerated ray-curve intersection
-//
-// Works on both WebGPU and WebGL backends via Three.js TSL
-//
-// Compared to the raw GLSL/WGSL standalone renderers, this adapter
-// trades some features for Three.js integration:
-//   - No vertex dilation (may cause sub-pixel edge clipping at extreme zoom)
-//   - No adaptive supersampling (single-sample per fragment)
-//
-// Requires peer dependencies: three, three/tsl
+// No vertex dilation or adaptive supersampling (unlike the raw
+// GLSL/WGSL renderers); may clip at sub-pixel edges under extreme zoom
 // @ts-ignore - three is a peer dependency
 const LOG_BAND_TEX_W = 12;
 const BAND_TEX_W_MASK = (1 << LOG_BAND_TEX_W) - 1;
@@ -100,10 +91,6 @@ const calcBandLoc = tsl.Fn(([glyphX, glyphY, offset]) => {
     bx.assign(bx.bitAnd(BAND_TEX_W_MASK));
     return tsl.ivec2(bx, by);
 });
-// Create a Three.js Mesh from SlugGPUData using TSL node materials.
-// Returns a single transparent mesh suitable for any Three.js scene.
-// The Slug algorithm evaluates per-fragment coverage analytically,
-// so no stencil buffer or multi-pass rendering is required
 function createSlugTSLMesh(gpuData, color) {
     const attrs = index.unpackSlugVertices(gpuData);
     const geo = new THREE__namespace.BufferGeometry();
@@ -130,16 +117,11 @@ function createSlugTSLMesh(gpuData, color) {
     bandTex.magFilter = THREE__namespace.NearestFilter;
     bandTex.generateMipmaps = false;
     bandTex.needsUpdate = true;
-    // Varyings: vertex attributes interpolated to fragment stage
     const vTexcoord = tsl.varying(tsl.attribute('slugTexcoord', 'vec2'), 'v_texcoord');
     const vBanding = tsl.varying(tsl.attribute('slugBanding', 'vec4'), 'v_banding');
     const vGlyph = tsl.varying(tsl.attribute('slugGlyph', 'vec4'), 'v_glyph');
     const vColor = tsl.varying(tsl.attribute('slugColor', 'vec4'), 'v_color');
-    // Color uniform (allows dynamic color updates)
     const textColor = tsl.uniform(new THREE__namespace.Color(color?.r ?? 1, color?.g ?? 1, color?.b ?? 1));
-    // Main per-fragment evaluation: SlugRenderSingle ported to TSL
-    // Evaluates horizontal and vertical band loops to compute
-    // analytic winding-number coverage
     const slugRenderSingle = tsl.Fn(([renderCoord, emsPerPixel, bandTransform, glyphData]) => {
         const pixelsPerEm = tsl.vec2(tsl.float(1).div(emsPerPixel.x), tsl.float(1).div(emsPerPixel.y));
         const glyphLocX = glyphData.x.toInt();
@@ -148,7 +130,6 @@ function createSlugTSLMesh(gpuData, color) {
         const bandMaxY = glyphData.w.toInt().bitAnd(0xFF);
         const bandIdxX = tsl.max(tsl.min(renderCoord.x.mul(bandTransform.x).add(bandTransform.z).toInt(), bandMaxX), tsl.int(0));
         const bandIdxY = tsl.max(tsl.min(renderCoord.y.mul(bandTransform.y).add(bandTransform.w).toInt(), bandMaxY), tsl.int(0));
-        // Horizontal band loop
         const xcov = tsl.float(0).toVar();
         const xwgt = tsl.float(0).toVar();
         const hbandData = tsl.textureLoad(bandTex, tsl.ivec2(glyphLocX.add(bandIdxY), glyphLocY));
@@ -181,7 +162,6 @@ function createSlugTSLMesh(gpuData, color) {
             });
             hIdx.addAssign(1);
         });
-        // Vertical band loop
         const ycov = tsl.float(0).toVar();
         const ywgt = tsl.float(0).toVar();
         const vbandOffset = bandMaxY.add(1).add(bandIdxX);
@@ -215,17 +195,14 @@ function createSlugTSLMesh(gpuData, color) {
             });
             vIdx.addAssign(1);
         });
-        // CalcCoverage (nonzero winding rule)
         const coverage = tsl.max(tsl.abs(xcov.mul(xwgt).add(ycov.mul(ywgt))).div(tsl.max(xwgt.add(ywgt), tsl.float(1.0 / 65536.0))), tsl.min(tsl.abs(xcov), tsl.abs(ycov)));
         return tsl.clamp(coverage, 0, 1);
     });
-    // Top-level fragment node
     const fragmentNode = tsl.Fn(() => {
         const emsPerPixel = tsl.fwidth(vTexcoord);
         const coverage = slugRenderSingle(vTexcoord, emsPerPixel, vBanding, vGlyph);
         return tsl.vec4(textColor.x, textColor.y, textColor.z, vColor.w.mul(coverage));
     })();
-    // Material & mesh
     const material = new webgpu.MeshBasicNodeMaterial();
     material.fragmentNode = fragmentNode;
     material.transparent = true;

package/dist/vector/slugTSL.js

@@ -4,20 +4,11 @@ import { Fn, select, uint, float, sqrt, max, If, abs, vec2, ivec2, varying, attr
 import { u as unpackSlugVertices } from './index2.js';
 import './core/index.js';
 
-// Slug TSL adapter for Three.js WebGPURenderer (and WebGL via r170+)
+// Slug adapter using Three.js TSL (node materials)
+// Works on both WebGPU and WebGL backends (r170+)
 //
-// Creates a single Three.js Mesh with a NodeMaterial that implements
-// the Slug algorithm: per-fragment winding number evaluation via
-// band-accelerated ray-curve intersection
-//
-// Works on both WebGPU and WebGL backends via Three.js TSL
-//
-// Compared to the raw GLSL/WGSL standalone renderers, this adapter
-// trades some features for Three.js integration:
-//   - No vertex dilation (may cause sub-pixel edge clipping at extreme zoom)
-//   - No adaptive supersampling (single-sample per fragment)
-//
-// Requires peer dependencies: three, three/tsl
+// No vertex dilation or adaptive supersampling (unlike the raw
+// GLSL/WGSL renderers); may clip at sub-pixel edges under extreme zoom
 // @ts-ignore - three is a peer dependency
 const LOG_BAND_TEX_W = 12;
 const BAND_TEX_W_MASK = (1 << LOG_BAND_TEX_W) - 1;
@@ -79,10 +70,6 @@ const calcBandLoc = Fn(([glyphX, glyphY, offset]) => {
     bx.assign(bx.bitAnd(BAND_TEX_W_MASK));
     return ivec2(bx, by);
 });
-// Create a Three.js Mesh from SlugGPUData using TSL node materials.
-// Returns a single transparent mesh suitable for any Three.js scene.
-// The Slug algorithm evaluates per-fragment coverage analytically,
-// so no stencil buffer or multi-pass rendering is required
 function createSlugTSLMesh(gpuData, color) {
     const attrs = unpackSlugVertices(gpuData);
     const geo = new THREE.BufferGeometry();
@@ -109,16 +96,11 @@ function createSlugTSLMesh(gpuData, color) {
     bandTex.magFilter = THREE.NearestFilter;
     bandTex.generateMipmaps = false;
     bandTex.needsUpdate = true;
-    // Varyings: vertex attributes interpolated to fragment stage
     const vTexcoord = varying(attribute('slugTexcoord', 'vec2'), 'v_texcoord');
     const vBanding = varying(attribute('slugBanding', 'vec4'), 'v_banding');
     const vGlyph = varying(attribute('slugGlyph', 'vec4'), 'v_glyph');
     const vColor = varying(attribute('slugColor', 'vec4'), 'v_color');
-    // Color uniform (allows dynamic color updates)
     const textColor = uniform(new THREE.Color(color?.r ?? 1, color?.g ?? 1, color?.b ?? 1));
-    // Main per-fragment evaluation: SlugRenderSingle ported to TSL
-    // Evaluates horizontal and vertical band loops to compute
-    // analytic winding-number coverage
     const slugRenderSingle = Fn(([renderCoord, emsPerPixel, bandTransform, glyphData]) => {
         const pixelsPerEm = vec2(float(1).div(emsPerPixel.x), float(1).div(emsPerPixel.y));
         const glyphLocX = glyphData.x.toInt();
@@ -127,7 +109,6 @@ function createSlugTSLMesh(gpuData, color) {
         const bandMaxY = glyphData.w.toInt().bitAnd(0xFF);
         const bandIdxX = max(min(renderCoord.x.mul(bandTransform.x).add(bandTransform.z).toInt(), bandMaxX), int(0));
         const bandIdxY = max(min(renderCoord.y.mul(bandTransform.y).add(bandTransform.w).toInt(), bandMaxY), int(0));
-        // Horizontal band loop
         const xcov = float(0).toVar();
         const xwgt = float(0).toVar();
         const hbandData = textureLoad(bandTex, ivec2(glyphLocX.add(bandIdxY), glyphLocY));
@@ -160,7 +141,6 @@ function createSlugTSLMesh(gpuData, color) {
             });
             hIdx.addAssign(1);
         });
-        // Vertical band loop
         const ycov = float(0).toVar();
         const ywgt = float(0).toVar();
         const vbandOffset = bandMaxY.add(1).add(bandIdxX);
@@ -194,17 +174,14 @@ function createSlugTSLMesh(gpuData, color) {
             });
             vIdx.addAssign(1);
         });
-        // CalcCoverage (nonzero winding rule)
         const coverage = max(abs(xcov.mul(xwgt).add(ycov.mul(ywgt))).div(max(xwgt.add(ywgt), float(1.0 / 65536.0))), min(abs(xcov), abs(ycov)));
         return clamp(coverage, 0, 1);
     });
-    // Top-level fragment node
     const fragmentNode = Fn(() => {
         const emsPerPixel = fwidth(vTexcoord);
         const coverage = slugRenderSingle(vTexcoord, emsPerPixel, vBanding, vGlyph);
         return vec4(textColor.x, textColor.y, textColor.z, vColor.w.mul(coverage));
     })();
-    // Material & mesh
     const material = new MeshBasicNodeMaterial();
     material.fragmentNode = fragmentNode;
     material.transparent = true;

package/dist/vector/webgl/index.cjs

@@ -1,12 +1,9 @@
 'use strict';
 
-var vertGLSL = "#version 300 es\n// GLSL 300 es port of the Slug vertex shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n// Per-vertex attributes (5 x vec4, matching Slug reference layout)\nlayout(location = 0) in vec4 a_pos; // .xy = object-space position, .zw = outward normal\nlayout(location = 1) in vec4 a_tex; // .xy = em-space sample coords, .z = packed glyph loc, .w = packed band max + flags\nlayout(location = 2) in vec4 a_jac; // inverse Jacobian (2x2): (j00, j01, j10, j11)\nlayout(location = 3) in vec4 a_bnd; // (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)\nlayout(location = 4) in vec4 a_col; // vertex color RGBA\n\nuniform mat4 slug_matrix;    // MVP matrix (rows as vec4s)\nuniform vec2 slug_viewport;  // viewport dimensions in pixels\n\nout vec4 v_color;\nout vec2 v_texcoord;\nflat out vec4 v_banding;\nflat out ivec4 v_glyph;\n\nvoid SlugUnpack(vec4 tex, vec4 bnd, out vec4 vbnd, out ivec4 vgly) {\n    uvec2 g = floatBitsToUint(tex.zw);\n    vgly = ivec4(g.x & 0xFFFFu, g.x >> 16u, g.y & 0xFFFFu, g.y >> 16u);\n    vbnd = bnd;\n}\n\nvec2 SlugDilate(vec4 pos, vec4 tex, vec4 jac, vec4 m0, vec4 m1, vec4 m3, vec2 dim, out vec2 vpos) {\n    vec2 n = normalize(pos.zw);\n    float s = dot(m3.xy, pos.xy) + m3.w;\n    float t = dot(m3.xy, n);\n\n    float u = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    float v = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    float s2 = s * s;\n    float st = s * t;\n    float uv = u * u + v * v;\n    vec2 d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    vpos = pos.xy + d;\n    return vec2(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n}\n\nvoid main() {\n    vec2 p;\n\n    // Dynamic dilation: expand quad by a pixel to prevent edge clipping.\n    v_texcoord = SlugDilate(a_pos, a_tex, a_jac,\n                            slug_matrix[0], slug_matrix[1], slug_matrix[3],\n                            slug_viewport, p);\n\n    // MVP transform on dilated position.\n    gl_Position.x = p.x * slug_matrix[0].x + p.y * slug_matrix[0].y + slug_matrix[0].w;\n    gl_Position.y = p.x * slug_matrix[1].x + p.y * slug_matrix[1].y + slug_matrix[1].w;\n    gl_Position.z = p.x * slug_matrix[2].x + p.y * slug_matrix[2].y + slug_matrix[2].w;\n    gl_Position.w = p.x * slug_matrix[3].x + p.y * slug_matrix[3].y + slug_matrix[3].w;\n\n    SlugUnpack(a_tex, a_bnd, v_banding, v_glyph);\n    v_color = a_col;\n}\n";
+var vertGLSL = "#version 300 es\n// GLSL 300 es port of the Slug vertex shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n// Per-vertex attributes (5 x vec4, matching Slug reference layout)\nlayout(location = 0) in vec4 a_pos; // .xy = object-space position, .zw = outward normal\nlayout(location = 1) in vec4 a_tex; // .xy = em-space sample coords, .z = packed glyph loc, .w = packed band max + flags\nlayout(location = 2) in vec4 a_jac; // inverse Jacobian (2x2): (j00, j01, j10, j11)\nlayout(location = 3) in vec4 a_bnd; // (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)\nlayout(location = 4) in vec4 a_col; // vertex color RGBA\n\nuniform mat4 slug_matrix;    // MVP matrix (rows as vec4s)\nuniform vec2 slug_viewport;  // viewport dimensions in pixels\n\nout vec4 v_color;\nout vec2 v_texcoord;\nflat out vec4 v_banding;\nflat out ivec4 v_glyph;\n\nvoid SlugUnpack(vec4 tex, vec4 bnd, out vec4 vbnd, out ivec4 vgly) {\n    uvec2 g = floatBitsToUint(tex.zw);\n    vgly = ivec4(g.x & 0xFFFFu, g.x >> 16u, g.y & 0xFFFFu, g.y >> 16u);\n    vbnd = bnd;\n}\n\nvec2 SlugDilate(vec4 pos, vec4 tex, vec4 jac, vec4 m0, vec4 m1, vec4 m3, vec2 dim, out vec2 vpos) {\n    vec2 n = normalize(pos.zw);\n    float s = dot(m3.xy, pos.xy) + m3.w;\n    float t = dot(m3.xy, n);\n\n    float u = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    float v = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    float s2 = s * s;\n    float st = s * t;\n    float uv = u * u + v * v;\n    vec2 d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    vpos = pos.xy + d;\n    return vec2(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n}\n\nvoid main() {\n    vec2 p;\n\n    // Dynamic dilation: expand quad by a pixel to prevent edge clipping\n    v_texcoord = SlugDilate(a_pos, a_tex, a_jac,\n                            slug_matrix[0], slug_matrix[1], slug_matrix[3],\n                            slug_viewport, p);\n\n    // MVP transform on dilated position\n    gl_Position.x = p.x * slug_matrix[0].x + p.y * slug_matrix[0].y + slug_matrix[0].w;\n    gl_Position.y = p.x * slug_matrix[1].x + p.y * slug_matrix[1].y + slug_matrix[1].w;\n    gl_Position.z = p.x * slug_matrix[2].x + p.y * slug_matrix[2].y + slug_matrix[2].w;\n    gl_Position.w = p.x * slug_matrix[3].x + p.y * slug_matrix[3].y + slug_matrix[3].w;\n\n    SlugUnpack(a_tex, a_bnd, v_banding, v_glyph);\n    v_color = a_col;\n}\n";
 
 var fragGLSL = "#version 300 es\n// GLSL 300 es port of the Slug fragment shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n#define kLogBandTextureWidth 12\n\nin vec4 v_color;\nin vec2 v_texcoord;\nflat in vec4 v_banding;\nflat in ivec4 v_glyph;\n\nuniform sampler2D curveTexture;     // RGBA32F control points\nuniform highp usampler2D bandTexture; // RGBA32UI band data\n\nlayout(location = 0) out vec4 outColor;\n\nuint CalcRootCode(float y1, float y2, float y3) {\n    uint i1 = floatBitsToUint(y1) >> 31u;\n    uint i2 = floatBitsToUint(y2) >> 30u;\n    uint i3 = floatBitsToUint(y3) >> 29u;\n\n    uint shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nvec2 SolveHorizPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.y;\n    float rb = 0.5 / b.y;\n\n    float d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    float t1 = (b.y - d) * ra;\n    float t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) t1 = t2 = p12.y * rb;\n\n    return vec2((a.x * t1 - b.x * 2.0) * t1 + p12.x, (a.x * t2 - b.x * 2.0) * t2 + p12.x);\n}\n\nvec2 SolveVertPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.x;\n    float rb = 0.5 / b.x;\n\n    float d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    float t1 = (b.x - d) * ra;\n    float t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) t1 = t2 = p12.x * rb;\n\n    return vec2((a.y * t1 - b.y * 2.0) * t1 + p12.y, (a.y * t2 - b.y * 2.0) * t2 + p12.y);\n}\n\nivec2 CalcBandLoc(ivec2 glyphLoc, uint offset) {\n    ivec2 bandLoc = ivec2(glyphLoc.x + int(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> kLogBandTextureWidth;\n    bandLoc.x &= (1 << kLogBandTextureWidth) - 1;\n    return bandLoc;\n}\n\nfloat CalcCoverage(float xcov, float ycov, float xwgt, float ywgt, int flags) {\n    float coverage = max(abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0), min(abs(xcov), abs(ycov)));\n\n#if defined(SLUG_EVENODD)\n    if ((flags & 0x1000) == 0) {\n#endif\n        coverage = clamp(coverage, 0.0, 1.0);\n#if defined(SLUG_EVENODD)\n    } else {\n        coverage = 1.0 - abs(1.0 - fract(coverage * 0.5) * 2.0);\n    }\n#endif\n\n#if defined(SLUG_WEIGHT)\n    coverage = sqrt(coverage);\n#endif\n\n    return coverage;\n}\n\nfloat SlugRenderSingle(vec2 renderCoord, vec2 emsPerPixel, vec4 bandTransform, ivec4 glyphData) {\n    int curveIndex;\n\n    vec2 pixelsPerEm = 1.0 / emsPerPixel;\n\n    ivec2 bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    ivec2 bandIndex = clamp(ivec2(renderCoord * bandTransform.xy + bandTransform.zw), ivec2(0, 0), bandMax);\n    ivec2 glyphLoc = glyphData.xy;\n\n    float xcov = 0.0;\n    float xwgt = 0.0;\n\n    uvec2 hbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    ivec2 hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(hbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(hbandLoc.x + curveIndex, hbandLoc.y), 0).xy);\n\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break;\n\n        uint code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            vec2 r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    float ycov = 0.0;\n    float ywgt = 0.0;\n\n    uvec2 vbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    ivec2 vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(vbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(vbandLoc.x + curveIndex, vbandLoc.y), 0).xy);\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break;\n\n        uint code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            vec2 r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt, glyphData.w);\n}\n\nfloat SlugRender(vec2 renderCoord, vec4 bandTransform, ivec4 glyphData) {\n    vec2 emsPerPixel = fwidth(renderCoord);\n\n#if defined(SLUG_ADAPTIVE_SUPERSAMPLE)\n    // Per-pixel rotated RGSS-4.  The base RGSS offsets are rotated by a\n    // unique angle per fragment (interleaved gradient noise).  This converts\n    // structured aliasing shimmer into uncorrelated grain that the eye\n    // naturally filters out, much closer to how hardware MSAA on many small\n    // triangles behaves perceptually.\n    float noise = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n    float angle = noise * 6.2831853;\n    float ca = cos(angle), sa = sin(angle);\n\n    // Base RGSS offsets rotated by per-pixel angle\n    vec2 o0 = vec2(ca * -0.375 - sa *  0.125, sa * -0.375 + ca *  0.125) * emsPerPixel;\n    vec2 o1 = vec2(ca *  0.125 - sa *  0.375, sa *  0.125 + ca *  0.375) * emsPerPixel;\n    vec2 o2 = vec2(ca *  0.375 - sa * -0.125, sa *  0.375 + ca * -0.125) * emsPerPixel;\n    vec2 o3 = vec2(ca * -0.125 - sa * -0.375, sa * -0.125 + ca * -0.375) * emsPerPixel;\n\n    float coverage =\n        SlugRenderSingle(renderCoord + o0, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o1, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o2, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o3, emsPerPixel, bandTransform, glyphData);\n    return coverage * 0.25;\n#else\n    return SlugRenderSingle(renderCoord, emsPerPixel, bandTransform, glyphData);\n#endif\n}\n\nvoid main() {\n    float coverage = SlugRender(v_texcoord, v_banding, v_glyph);\n    outColor = v_color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const vertexShaderGLSL300 = vertGLSL;
 const fragmentShaderGLSL300 = fragGLSL;

package/dist/vector/webgl/index.js

@@ -1,10 +1,7 @@
-var vertGLSL = "#version 300 es\n// GLSL 300 es port of the Slug vertex shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n// Per-vertex attributes (5 x vec4, matching Slug reference layout)\nlayout(location = 0) in vec4 a_pos; // .xy = object-space position, .zw = outward normal\nlayout(location = 1) in vec4 a_tex; // .xy = em-space sample coords, .z = packed glyph loc, .w = packed band max + flags\nlayout(location = 2) in vec4 a_jac; // inverse Jacobian (2x2): (j00, j01, j10, j11)\nlayout(location = 3) in vec4 a_bnd; // (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)\nlayout(location = 4) in vec4 a_col; // vertex color RGBA\n\nuniform mat4 slug_matrix;    // MVP matrix (rows as vec4s)\nuniform vec2 slug_viewport;  // viewport dimensions in pixels\n\nout vec4 v_color;\nout vec2 v_texcoord;\nflat out vec4 v_banding;\nflat out ivec4 v_glyph;\n\nvoid SlugUnpack(vec4 tex, vec4 bnd, out vec4 vbnd, out ivec4 vgly) {\n    uvec2 g = floatBitsToUint(tex.zw);\n    vgly = ivec4(g.x & 0xFFFFu, g.x >> 16u, g.y & 0xFFFFu, g.y >> 16u);\n    vbnd = bnd;\n}\n\nvec2 SlugDilate(vec4 pos, vec4 tex, vec4 jac, vec4 m0, vec4 m1, vec4 m3, vec2 dim, out vec2 vpos) {\n    vec2 n = normalize(pos.zw);\n    float s = dot(m3.xy, pos.xy) + m3.w;\n    float t = dot(m3.xy, n);\n\n    float u = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    float v = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    float s2 = s * s;\n    float st = s * t;\n    float uv = u * u + v * v;\n    vec2 d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    vpos = pos.xy + d;\n    return vec2(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n}\n\nvoid main() {\n    vec2 p;\n\n    // Dynamic dilation: expand quad by a pixel to prevent edge clipping.\n    v_texcoord = SlugDilate(a_pos, a_tex, a_jac,\n                            slug_matrix[0], slug_matrix[1], slug_matrix[3],\n                            slug_viewport, p);\n\n    // MVP transform on dilated position.\n    gl_Position.x = p.x * slug_matrix[0].x + p.y * slug_matrix[0].y + slug_matrix[0].w;\n    gl_Position.y = p.x * slug_matrix[1].x + p.y * slug_matrix[1].y + slug_matrix[1].w;\n    gl_Position.z = p.x * slug_matrix[2].x + p.y * slug_matrix[2].y + slug_matrix[2].w;\n    gl_Position.w = p.x * slug_matrix[3].x + p.y * slug_matrix[3].y + slug_matrix[3].w;\n\n    SlugUnpack(a_tex, a_bnd, v_banding, v_glyph);\n    v_color = a_col;\n}\n";
+var vertGLSL = "#version 300 es\n// GLSL 300 es port of the Slug vertex shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n// Per-vertex attributes (5 x vec4, matching Slug reference layout)\nlayout(location = 0) in vec4 a_pos; // .xy = object-space position, .zw = outward normal\nlayout(location = 1) in vec4 a_tex; // .xy = em-space sample coords, .z = packed glyph loc, .w = packed band max + flags\nlayout(location = 2) in vec4 a_jac; // inverse Jacobian (2x2): (j00, j01, j10, j11)\nlayout(location = 3) in vec4 a_bnd; // (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)\nlayout(location = 4) in vec4 a_col; // vertex color RGBA\n\nuniform mat4 slug_matrix;    // MVP matrix (rows as vec4s)\nuniform vec2 slug_viewport;  // viewport dimensions in pixels\n\nout vec4 v_color;\nout vec2 v_texcoord;\nflat out vec4 v_banding;\nflat out ivec4 v_glyph;\n\nvoid SlugUnpack(vec4 tex, vec4 bnd, out vec4 vbnd, out ivec4 vgly) {\n    uvec2 g = floatBitsToUint(tex.zw);\n    vgly = ivec4(g.x & 0xFFFFu, g.x >> 16u, g.y & 0xFFFFu, g.y >> 16u);\n    vbnd = bnd;\n}\n\nvec2 SlugDilate(vec4 pos, vec4 tex, vec4 jac, vec4 m0, vec4 m1, vec4 m3, vec2 dim, out vec2 vpos) {\n    vec2 n = normalize(pos.zw);\n    float s = dot(m3.xy, pos.xy) + m3.w;\n    float t = dot(m3.xy, n);\n\n    float u = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    float v = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    float s2 = s * s;\n    float st = s * t;\n    float uv = u * u + v * v;\n    vec2 d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    vpos = pos.xy + d;\n    return vec2(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n}\n\nvoid main() {\n    vec2 p;\n\n    // Dynamic dilation: expand quad by a pixel to prevent edge clipping\n    v_texcoord = SlugDilate(a_pos, a_tex, a_jac,\n                            slug_matrix[0], slug_matrix[1], slug_matrix[3],\n                            slug_viewport, p);\n\n    // MVP transform on dilated position\n    gl_Position.x = p.x * slug_matrix[0].x + p.y * slug_matrix[0].y + slug_matrix[0].w;\n    gl_Position.y = p.x * slug_matrix[1].x + p.y * slug_matrix[1].y + slug_matrix[1].w;\n    gl_Position.z = p.x * slug_matrix[2].x + p.y * slug_matrix[2].y + slug_matrix[2].w;\n    gl_Position.w = p.x * slug_matrix[3].x + p.y * slug_matrix[3].y + slug_matrix[3].w;\n\n    SlugUnpack(a_tex, a_bnd, v_banding, v_glyph);\n    v_color = a_col;\n}\n";
 
 var fragGLSL = "#version 300 es\n// GLSL 300 es port of the Slug fragment shader\n// Eric Lengyel, MIT License, 2017\n\nprecision highp float;\nprecision highp int;\n\n#define kLogBandTextureWidth 12\n\nin vec4 v_color;\nin vec2 v_texcoord;\nflat in vec4 v_banding;\nflat in ivec4 v_glyph;\n\nuniform sampler2D curveTexture;     // RGBA32F control points\nuniform highp usampler2D bandTexture; // RGBA32UI band data\n\nlayout(location = 0) out vec4 outColor;\n\nuint CalcRootCode(float y1, float y2, float y3) {\n    uint i1 = floatBitsToUint(y1) >> 31u;\n    uint i2 = floatBitsToUint(y2) >> 30u;\n    uint i3 = floatBitsToUint(y3) >> 29u;\n\n    uint shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nvec2 SolveHorizPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.y;\n    float rb = 0.5 / b.y;\n\n    float d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    float t1 = (b.y - d) * ra;\n    float t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) t1 = t2 = p12.y * rb;\n\n    return vec2((a.x * t1 - b.x * 2.0) * t1 + p12.x, (a.x * t2 - b.x * 2.0) * t2 + p12.x);\n}\n\nvec2 SolveVertPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.x;\n    float rb = 0.5 / b.x;\n\n    float d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    float t1 = (b.x - d) * ra;\n    float t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) t1 = t2 = p12.x * rb;\n\n    return vec2((a.y * t1 - b.y * 2.0) * t1 + p12.y, (a.y * t2 - b.y * 2.0) * t2 + p12.y);\n}\n\nivec2 CalcBandLoc(ivec2 glyphLoc, uint offset) {\n    ivec2 bandLoc = ivec2(glyphLoc.x + int(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> kLogBandTextureWidth;\n    bandLoc.x &= (1 << kLogBandTextureWidth) - 1;\n    return bandLoc;\n}\n\nfloat CalcCoverage(float xcov, float ycov, float xwgt, float ywgt, int flags) {\n    float coverage = max(abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0), min(abs(xcov), abs(ycov)));\n\n#if defined(SLUG_EVENODD)\n    if ((flags & 0x1000) == 0) {\n#endif\n        coverage = clamp(coverage, 0.0, 1.0);\n#if defined(SLUG_EVENODD)\n    } else {\n        coverage = 1.0 - abs(1.0 - fract(coverage * 0.5) * 2.0);\n    }\n#endif\n\n#if defined(SLUG_WEIGHT)\n    coverage = sqrt(coverage);\n#endif\n\n    return coverage;\n}\n\nfloat SlugRenderSingle(vec2 renderCoord, vec2 emsPerPixel, vec4 bandTransform, ivec4 glyphData) {\n    int curveIndex;\n\n    vec2 pixelsPerEm = 1.0 / emsPerPixel;\n\n    ivec2 bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    ivec2 bandIndex = clamp(ivec2(renderCoord * bandTransform.xy + bandTransform.zw), ivec2(0, 0), bandMax);\n    ivec2 glyphLoc = glyphData.xy;\n\n    float xcov = 0.0;\n    float xwgt = 0.0;\n\n    uvec2 hbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    ivec2 hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(hbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(hbandLoc.x + curveIndex, hbandLoc.y), 0).xy);\n\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break;\n\n        uint code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            vec2 r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    float ycov = 0.0;\n    float ywgt = 0.0;\n\n    uvec2 vbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    ivec2 vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(vbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(vbandLoc.x + curveIndex, vbandLoc.y), 0).xy);\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break;\n\n        uint code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            vec2 r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt, glyphData.w);\n}\n\nfloat SlugRender(vec2 renderCoord, vec4 bandTransform, ivec4 glyphData) {\n    vec2 emsPerPixel = fwidth(renderCoord);\n\n#if defined(SLUG_ADAPTIVE_SUPERSAMPLE)\n    // Per-pixel rotated RGSS-4.  The base RGSS offsets are rotated by a\n    // unique angle per fragment (interleaved gradient noise).  This converts\n    // structured aliasing shimmer into uncorrelated grain that the eye\n    // naturally filters out, much closer to how hardware MSAA on many small\n    // triangles behaves perceptually.\n    float noise = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n    float angle = noise * 6.2831853;\n    float ca = cos(angle), sa = sin(angle);\n\n    // Base RGSS offsets rotated by per-pixel angle\n    vec2 o0 = vec2(ca * -0.375 - sa *  0.125, sa * -0.375 + ca *  0.125) * emsPerPixel;\n    vec2 o1 = vec2(ca *  0.125 - sa *  0.375, sa *  0.125 + ca *  0.375) * emsPerPixel;\n    vec2 o2 = vec2(ca *  0.375 - sa * -0.125, sa *  0.375 + ca * -0.125) * emsPerPixel;\n    vec2 o3 = vec2(ca * -0.125 - sa * -0.375, sa * -0.125 + ca * -0.375) * emsPerPixel;\n\n    float coverage =\n        SlugRenderSingle(renderCoord + o0, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o1, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o2, emsPerPixel, bandTransform, glyphData) +\n        SlugRenderSingle(renderCoord + o3, emsPerPixel, bandTransform, glyphData);\n    return coverage * 0.25;\n#else\n    return SlugRenderSingle(renderCoord, emsPerPixel, bandTransform, glyphData);\n#endif\n}\n\nvoid main() {\n    float coverage = SlugRender(v_texcoord, v_banding, v_glyph);\n    outColor = v_color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const vertexShaderGLSL300 = vertGLSL;
 const fragmentShaderGLSL300 = fragGLSL;

package/dist/vector/webgpu/index.cjs

@@ -4,9 +4,6 @@ var vertWGSL = "// WGSL port of the reference Slug vertex shader\n// Original HL
 
 var fragWGSL = "// WGSL port of the reference Slug pixel shader\n// by Eric Lengyel, MIT License, Copyright 2017\n\nconst kLogBandTextureWidth: u32 = 12u;\n\n@group(0) @binding(1) var curveTexture: texture_2d<f32>;\n@group(0) @binding(2) var bandTexture: texture_2d<u32>;\n\nstruct FragmentInput {\n    @location(0) color: vec4<f32>,\n    @location(1) texcoord: vec2<f32>,\n    @location(2) @interpolate(flat) banding: vec4<f32>,\n    @location(3) @interpolate(flat) glyph: vec4<i32>,\n};\n\nfn CalcRootCode(y1: f32, y2: f32, y3: f32) -> u32 {\n    let i1 = bitcast<u32>(y1) >> 31u;\n    let i2 = bitcast<u32>(y2) >> 30u;\n    let i3 = bitcast<u32>(y3) >> 29u;\n\n    var shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nfn SolveHorizPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.y;\n    let rb = 0.5 / b.y;\n\n    let d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    var t1 = (b.y - d) * ra;\n    var t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) {\n        t1 = p12.y * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.x * t1 - b.x * 2.0) * t1 + p12.x,\n        (a.x * t2 - b.x * 2.0) * t2 + p12.x\n    );\n}\n\nfn SolveVertPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.x;\n    let rb = 0.5 / b.x;\n\n    let d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    var t1 = (b.x - d) * ra;\n    var t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) {\n        t1 = p12.x * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.y * t1 - b.y * 2.0) * t1 + p12.y,\n        (a.y * t2 - b.y * 2.0) * t2 + p12.y\n    );\n}\n\nfn CalcBandLoc(glyphLoc: vec2<i32>, offset: u32) -> vec2<i32> {\n    var bandLoc = vec2<i32>(glyphLoc.x + i32(offset), glyphLoc.y);\n    let bandShift = kLogBandTextureWidth;\n    let bandMask = i32((1u << bandShift) - 1u);\n    bandLoc.y += bandLoc.x >> bandShift;\n    bandLoc.x &= bandMask;\n    return bandLoc;\n}\n\nfn CalcCoverage(xcov: f32, ycov: f32, xwgt: f32, ywgt: f32) -> f32 {\n    var coverage = max(\n        abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0),\n        min(abs(xcov), abs(ycov))\n    );\n    coverage = clamp(coverage, 0.0, 1.0);\n    return coverage;\n}\n\nfn SlugRender(renderCoord: vec2<f32>, bandTransform: vec4<f32>, glyphData: vec4<i32>) -> f32 {\n    let emsPerPixel = fwidth(renderCoord);\n    let pixelsPerEm = 1.0 / emsPerPixel;\n\n    var bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    let bandIndex = clamp(\n        vec2<i32>(renderCoord * bandTransform.xy + bandTransform.zw),\n        vec2<i32>(0, 0),\n        bandMax\n    );\n    let glyphLoc = glyphData.xy;\n\n    var xcov = 0.0;\n    var xwgt = 0.0;\n\n    let hbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    let hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (var ci = 0; ci < i32(hbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(hbandLoc.x + ci, hbandLoc.y), 0).xy);\n\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) { break; }\n\n        let code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            let r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    var ycov = 0.0;\n    var ywgt = 0.0;\n\n    let vbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    let vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (var ci = 0; ci < i32(vbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(vbandLoc.x + ci, vbandLoc.y), 0).xy);\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) { break; }\n\n        let code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            let r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt);\n}\n\n@fragment\nfn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {\n    let coverage = SlugRender(in.texcoord, in.banding, in.glyph);\n    return in.color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const vertexShaderWGSL = vertWGSL;
 const fragmentShaderWGSL = fragWGSL;

package/dist/vector/webgpu/index.js

@@ -2,9 +2,6 @@ var vertWGSL = "// WGSL port of the reference Slug vertex shader\n// Original HL
 
 var fragWGSL = "// WGSL port of the reference Slug pixel shader\n// by Eric Lengyel, MIT License, Copyright 2017\n\nconst kLogBandTextureWidth: u32 = 12u;\n\n@group(0) @binding(1) var curveTexture: texture_2d<f32>;\n@group(0) @binding(2) var bandTexture: texture_2d<u32>;\n\nstruct FragmentInput {\n    @location(0) color: vec4<f32>,\n    @location(1) texcoord: vec2<f32>,\n    @location(2) @interpolate(flat) banding: vec4<f32>,\n    @location(3) @interpolate(flat) glyph: vec4<i32>,\n};\n\nfn CalcRootCode(y1: f32, y2: f32, y3: f32) -> u32 {\n    let i1 = bitcast<u32>(y1) >> 31u;\n    let i2 = bitcast<u32>(y2) >> 30u;\n    let i3 = bitcast<u32>(y3) >> 29u;\n\n    var shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nfn SolveHorizPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.y;\n    let rb = 0.5 / b.y;\n\n    let d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    var t1 = (b.y - d) * ra;\n    var t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) {\n        t1 = p12.y * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.x * t1 - b.x * 2.0) * t1 + p12.x,\n        (a.x * t2 - b.x * 2.0) * t2 + p12.x\n    );\n}\n\nfn SolveVertPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.x;\n    let rb = 0.5 / b.x;\n\n    let d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    var t1 = (b.x - d) * ra;\n    var t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) {\n        t1 = p12.x * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.y * t1 - b.y * 2.0) * t1 + p12.y,\n        (a.y * t2 - b.y * 2.0) * t2 + p12.y\n    );\n}\n\nfn CalcBandLoc(glyphLoc: vec2<i32>, offset: u32) -> vec2<i32> {\n    var bandLoc = vec2<i32>(glyphLoc.x + i32(offset), glyphLoc.y);\n    let bandShift = kLogBandTextureWidth;\n    let bandMask = i32((1u << bandShift) - 1u);\n    bandLoc.y += bandLoc.x >> bandShift;\n    bandLoc.x &= bandMask;\n    return bandLoc;\n}\n\nfn CalcCoverage(xcov: f32, ycov: f32, xwgt: f32, ywgt: f32) -> f32 {\n    var coverage = max(\n        abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0),\n        min(abs(xcov), abs(ycov))\n    );\n    coverage = clamp(coverage, 0.0, 1.0);\n    return coverage;\n}\n\nfn SlugRender(renderCoord: vec2<f32>, bandTransform: vec4<f32>, glyphData: vec4<i32>) -> f32 {\n    let emsPerPixel = fwidth(renderCoord);\n    let pixelsPerEm = 1.0 / emsPerPixel;\n\n    var bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    let bandIndex = clamp(\n        vec2<i32>(renderCoord * bandTransform.xy + bandTransform.zw),\n        vec2<i32>(0, 0),\n        bandMax\n    );\n    let glyphLoc = glyphData.xy;\n\n    var xcov = 0.0;\n    var xwgt = 0.0;\n\n    let hbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    let hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (var ci = 0; ci < i32(hbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(hbandLoc.x + ci, hbandLoc.y), 0).xy);\n\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) { break; }\n\n        let code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            let r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    var ycov = 0.0;\n    var ywgt = 0.0;\n\n    let vbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    let vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (var ci = 0; ci < i32(vbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(vbandLoc.x + ci, vbandLoc.y), 0).xy);\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) { break; }\n\n        let code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            let r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt);\n}\n\n@fragment\nfn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {\n    let coverage = SlugRender(in.texcoord, in.banding, in.glyph);\n    return in.color * coverage;\n}\n";
 
-// Slug shader source re-exports
-// The .glsl/.wgsl files are the single source of truth, imported as strings
-// at build time via the glslPlugin in rollup.config.js
 // @ts-ignore - resolved by rollup glslPlugin
 const vertexShaderWGSL = vertWGSL;
 const fragmentShaderWGSL = fragWGSL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-text",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "3D font rendering and text layout engine for the web",
   "main": "dist/three/index.cjs",
   "module": "dist/three/index.js",