three-text 0.6.0 → 0.6.2

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;
@@ -281,28 +278,33 @@ function packSlugData(shapes, options) {
     let curveY = 0;
     for (const shape of shapes) {
         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++;
             }
+            // 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;
             const base = (curveY * TEX_WIDTH + curveX) * 4;
-            curveData[base + 0] = curve.p1[0];
-            curveData[base + 1] = curve.p1[1];
-            curveData[base + 2] = curve.p2[0];
-            curveData[base + 3] = curve.p2[1];
+            curveData[base + 0] = lp1x;
+            curveData[base + 1] = lp1y;
+            curveData[base + 2] = lp2x;
+            curveData[base + 3] = lp2y;
             const base2 = base + 4;
-            curveData[base2 + 0] = curve.p3[0];
-            curveData[base2 + 1] = curve.p3[1];
-            const minX = Math.min(curve.p1[0], curve.p2[0], curve.p3[0]);
-            const minY = Math.min(curve.p1[1], curve.p2[1], curve.p3[1]);
-            const maxX = Math.max(curve.p1[0], curve.p2[0], curve.p3[0]);
-            const maxY = Math.max(curve.p1[1], curve.p2[1], curve.p3[1]);
+            curveData[base2 + 0] = lp3x;
+            curveData[base2 + 1] = lp3y;
+            const minX = Math.min(lp1x, lp2x, lp3x);
+            const minY = Math.min(lp1y, lp2y, lp3y);
+            const maxX = Math.max(lp1x, lp2x, lp3x);
+            const maxY = Math.max(lp1y, lp2y, lp3y);
             entries.push({
-                p1x: curve.p1[0], p1y: curve.p1[1],
-                p2x: curve.p2[0], p2y: curve.p2[1],
-                p3x: curve.p3[0], p3y: curve.p3[1],
+                p1x: lp1x, p1y: lp1y,
+                p2x: lp2x, p2y: lp2y,
+                p3x: lp3x, p3y: lp3y,
                 minX, minY, maxX, maxY,
                 curveTexX: curveX,
                 curveTexY: curveY
@@ -312,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++) {
@@ -337,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)
+        // Horizontal bands (partition y-axis)
         const hBands = [];
         const hLists = [];
         const bandH = h / hBandCount;
         for (let bi = 0; bi < hBandCount; bi++) {
-            const bandMinY = bMinY + bi * bandH;
+            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) {
@@ -360,12 +358,12 @@ function packSlugData(shapes, options) {
             hBands.push({ curveCount: list.length, listOffset: 0 });
             hLists.push(flatList);
         }
-        // Build vertical bands (partition x-axis)
+        // Vertical bands (partition x-axis)
         const vBands = [];
         const vLists = [];
         const bandW = w / vBandCount;
         for (let bi = 0; bi < vBandCount; bi++) {
-            const bandMinX = bMinX + bi * bandW;
+            const bandMinX = bi * bandW;
             const bandMaxXCoord = bandMinX + bandW;
             const list = [];
             for (const c of curves) {
@@ -373,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) {
@@ -382,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)
@@ -396,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 = [];
@@ -409,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;
@@ -422,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;
@@ -435,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;
@@ -459,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;
@@ -470,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;
@@ -481,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;
@@ -502,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];
@@ -528,32 +505,25 @@ 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 at corners (same as object-space for 1:1 mapping)
         const emCorners = [
-            [bMinX, bMinY],
-            [bMaxX, bMinY],
-            [bMaxX, bMaxY],
-            [bMinX, bMaxY],
+            [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 and offset to map em-coords to band indices
         const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
         const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
-        const bandOffsetX = -bMinX * bandScaleX;
-        const bandOffsetY = -bMinY * bandScaleY;
         for (let vi = 0; vi < 4; vi++) {
             const base = (si * 4 + vi) * FLOATS_PER_VERTEX;
             // pos: .xy = position, .zw = normal
@@ -566,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 = 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 and offset
+            // bnd: band scale (offset zero in glyph-local space)
             vertices[base + 12] = bandScaleX;
             vertices[base + 13] = bandScaleY;
-            vertices[base + 14] = bandOffsetX;
-            vertices[base + 15] = bandOffsetY;
-            // col: white with full alpha (caller overrides via uniform or attribute)
+            vertices[base + 14] = 0;
+            vertices[base + 15] = 0;
+            // 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;
@@ -791,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;