three-text 0.2.17 → 0.2.18

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.17
+ * three-text v0.2.18
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2727,7 +2727,9 @@ class Tessellator {
             tessContours = originalContours;
         }
         let extrusionContours = needsExtrusionContours
-            ? originalContours ?? this.pathsToContours(paths)
+            ? needsWindingReversal
+                ? tessContours
+                : originalContours ?? this.pathsToContours(paths)
             : [];
         if (removeOverlaps) {
             logger.log('Two-pass: boundary extraction then triangulation');
@@ -2749,24 +2751,6 @@ class Tessellator {
         }
         else {
             logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
-            // TTF contours may have inconsistent winding; check if we need normalization
-            if (needsExtrusionContours && !isCFF) {
-                const needsNormalization = this.needsWindingNormalization(extrusionContours);
-                if (needsNormalization) {
-                    logger.log('Complex topology detected, running boundary pass for winding normalization');
-                    perfLogger.start('Tessellator.windingNormalization', {
-                        contourCount: extrusionContours.length
-                    });
-                    const boundaryResult = this.performTessellation(extrusionContours, 'boundary');
-                    perfLogger.end('Tessellator.windingNormalization');
-                    if (boundaryResult) {
-                        extrusionContours = this.boundaryToContours(boundaryResult);
-                    }
-                }
-                else {
-                    logger.log('Simple topology, skipping winding normalization');
-                }
-            }
         }
         perfLogger.start('Tessellator.triangulationPass', {
             contourCount: tessContours.length
@@ -2948,28 +2932,58 @@ class Tessellator {
 
 class Extruder {
     constructor() { }
+    packEdge(a, b) {
+        const lo = a < b ? a : b;
+        const hi = a < b ? b : a;
+        return lo * 0x100000000 + hi;
+    }
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
         const numPoints = points.length / 2;
-        // Count side-wall segments (4 vertices + 6 indices per segment)
-        let sideSegments = 0;
+        // Count boundary edges for side walls (4 vertices + 6 indices per edge)
+        let boundaryEdges = [];
         if (depth !== 0) {
-            for (const contour of geometry.contours) {
-                // Contours are closed (last point repeats first)
-                const contourPoints = contour.length / 2;
-                if (contourPoints >= 2)
-                    sideSegments += contourPoints - 1;
+            const counts = new Map();
+            const oriented = new Map();
+            for (let i = 0; i < triangleIndices.length; i += 3) {
+                const a = triangleIndices[i];
+                const b = triangleIndices[i + 1];
+                const c = triangleIndices[i + 2];
+                const k0 = this.packEdge(a, b);
+                const n0 = (counts.get(k0) ?? 0) + 1;
+                counts.set(k0, n0);
+                if (n0 === 1)
+                    oriented.set(k0, [a, b]);
+                const k1 = this.packEdge(b, c);
+                const n1 = (counts.get(k1) ?? 0) + 1;
+                counts.set(k1, n1);
+                if (n1 === 1)
+                    oriented.set(k1, [b, c]);
+                const k2 = this.packEdge(c, a);
+                const n2 = (counts.get(k2) ?? 0) + 1;
+                counts.set(k2, n2);
+                if (n2 === 1)
+                    oriented.set(k2, [c, a]);
+            }
+            boundaryEdges = [];
+            for (const [key, count] of counts) {
+                if (count !== 1)
+                    continue;
+                const edge = oriented.get(key);
+                if (edge)
+                    boundaryEdges.push(edge);
             }
         }
-        const sideVertexCount = depth === 0 ? 0 : sideSegments * 4;
+        const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
+        const sideVertexCount = depth === 0 ? 0 : sideEdgeCount * 4;
         const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
         const vertexCount = baseVertexCount + sideVertexCount;
         const vertices = new Float32Array(vertexCount * 3);
         const normals = new Float32Array(vertexCount * 3);
         const indexCount = depth === 0
             ? triangleIndices.length
-            : triangleIndices.length * 2 + sideSegments * 6;
+            : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
             // Single-sided flat geometry at z=0
@@ -3025,60 +3039,62 @@ class Extruder {
         // Side walls
         let nextVertex = numPoints * 2;
         let idxPos = triangleIndices.length * 2;
-        for (const contour of geometry.contours) {
-            for (let i = 0; i < contour.length - 2; i += 2) {
-                const p0x = contour[i];
-                const p0y = contour[i + 1];
-                const p1x = contour[i + 2];
-                const p1y = contour[i + 3];
-                // Perpendicular normal for this wall segment
-                const ex = p1x - p0x;
-                const ey = p1y - p0y;
-                const lenSq = ex * ex + ey * ey;
-                let nx = 0;
-                let ny = 0;
-                if (lenSq > 0) {
-                    const invLen = 1 / Math.sqrt(lenSq);
-                    nx = ey * invLen;
-                    ny = -ex * invLen;
-                }
-                const baseVertex = nextVertex;
-                const base = baseVertex * 3;
-                // Wall quad: front edge at z=0, back edge at z=depth
-                vertices[base] = p0x;
-                vertices[base + 1] = p0y;
-                vertices[base + 2] = 0;
-                vertices[base + 3] = p1x;
-                vertices[base + 4] = p1y;
-                vertices[base + 5] = 0;
-                vertices[base + 6] = p0x;
-                vertices[base + 7] = p0y;
-                vertices[base + 8] = backZ;
-                vertices[base + 9] = p1x;
-                vertices[base + 10] = p1y;
-                vertices[base + 11] = backZ;
-                // Wall normals point perpendicular to edge
-                normals[base] = nx;
-                normals[base + 1] = ny;
-                normals[base + 2] = 0;
-                normals[base + 3] = nx;
-                normals[base + 4] = ny;
-                normals[base + 5] = 0;
-                normals[base + 6] = nx;
-                normals[base + 7] = ny;
-                normals[base + 8] = 0;
-                normals[base + 9] = nx;
-                normals[base + 10] = ny;
-                normals[base + 11] = 0;
-                // Two triangles per wall segment
-                indices[idxPos++] = baseVertex;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 2;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 3;
-                indices[idxPos++] = baseVertex + 2;
-                nextVertex += 4;
-            }
+        for (let e = 0; e < boundaryEdges.length; e++) {
+            const [u, v] = boundaryEdges[e];
+            const u2 = u * 2;
+            const v2 = v * 2;
+            const p0x = points[u2];
+            const p0y = points[u2 + 1];
+            const p1x = points[v2];
+            const p1y = points[v2 + 1];
+            // Perpendicular normal for this wall segment
+            // Uses the edge direction from the cap triangulation so winding does not depend on contour direction
+            const ex = p1x - p0x;
+            const ey = p1y - p0y;
+            const lenSq = ex * ex + ey * ey;
+            let nx = 0;
+            let ny = 0;
+            if (lenSq > 0) {
+                const invLen = 1 / Math.sqrt(lenSq);
+                nx = ey * invLen;
+                ny = -ex * invLen;
+            }
+            const baseVertex = nextVertex;
+            const base = baseVertex * 3;
+            // Wall quad: front edge at z=0, back edge at z=depth
+            vertices[base] = p0x;
+            vertices[base + 1] = p0y;
+            vertices[base + 2] = 0;
+            vertices[base + 3] = p1x;
+            vertices[base + 4] = p1y;
+            vertices[base + 5] = 0;
+            vertices[base + 6] = p0x;
+            vertices[base + 7] = p0y;
+            vertices[base + 8] = backZ;
+            vertices[base + 9] = p1x;
+            vertices[base + 10] = p1y;
+            vertices[base + 11] = backZ;
+            // Wall normals point perpendicular to edge
+            normals[base] = nx;
+            normals[base + 1] = ny;
+            normals[base + 2] = 0;
+            normals[base + 3] = nx;
+            normals[base + 4] = ny;
+            normals[base + 5] = 0;
+            normals[base + 6] = nx;
+            normals[base + 7] = ny;
+            normals[base + 8] = 0;
+            normals[base + 9] = nx;
+            normals[base + 10] = ny;
+            normals[base + 11] = 0;
+            // Two triangles per wall segment
+            indices[idxPos++] = baseVertex;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 2;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 3;
+            indices[idxPos++] = baseVertex + 2;
+            nextVertex += 4;
         }
         return { vertices, normals, indices };
     }
@@ -4177,7 +4193,7 @@ class GlyphGeometryBuilder {
                 // Use glyph-level caching when separateGlyphs is set or when cluster contains colored text
                 const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
                 // Iterate over the geometric groups identified by BoundaryClusterer
-                // logical groups (words) split into geometric sub-groups (e.g. "aa", "XX", "bb")
+                // logical groups (words) split into geometric sub-groups
                 for (const groupIndices of boundaryGroups) {
                     const isOverlappingGroup = groupIndices.length > 1;
                     const shouldCluster = isOverlappingGroup && !forceSeparate;

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.17
+ * three-text v0.2.18
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2724,7 +2724,9 @@ class Tessellator {
             tessContours = originalContours;
         }
         let extrusionContours = needsExtrusionContours
-            ? originalContours ?? this.pathsToContours(paths)
+            ? needsWindingReversal
+                ? tessContours
+                : originalContours ?? this.pathsToContours(paths)
             : [];
         if (removeOverlaps) {
             logger.log('Two-pass: boundary extraction then triangulation');
@@ -2746,24 +2748,6 @@ class Tessellator {
         }
         else {
             logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
-            // TTF contours may have inconsistent winding; check if we need normalization
-            if (needsExtrusionContours && !isCFF) {
-                const needsNormalization = this.needsWindingNormalization(extrusionContours);
-                if (needsNormalization) {
-                    logger.log('Complex topology detected, running boundary pass for winding normalization');
-                    perfLogger.start('Tessellator.windingNormalization', {
-                        contourCount: extrusionContours.length
-                    });
-                    const boundaryResult = this.performTessellation(extrusionContours, 'boundary');
-                    perfLogger.end('Tessellator.windingNormalization');
-                    if (boundaryResult) {
-                        extrusionContours = this.boundaryToContours(boundaryResult);
-                    }
-                }
-                else {
-                    logger.log('Simple topology, skipping winding normalization');
-                }
-            }
         }
         perfLogger.start('Tessellator.triangulationPass', {
             contourCount: tessContours.length
@@ -2945,28 +2929,58 @@ class Tessellator {
 
 class Extruder {
     constructor() { }
+    packEdge(a, b) {
+        const lo = a < b ? a : b;
+        const hi = a < b ? b : a;
+        return lo * 0x100000000 + hi;
+    }
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
         const numPoints = points.length / 2;
-        // Count side-wall segments (4 vertices + 6 indices per segment)
-        let sideSegments = 0;
+        // Count boundary edges for side walls (4 vertices + 6 indices per edge)
+        let boundaryEdges = [];
         if (depth !== 0) {
-            for (const contour of geometry.contours) {
-                // Contours are closed (last point repeats first)
-                const contourPoints = contour.length / 2;
-                if (contourPoints >= 2)
-                    sideSegments += contourPoints - 1;
+            const counts = new Map();
+            const oriented = new Map();
+            for (let i = 0; i < triangleIndices.length; i += 3) {
+                const a = triangleIndices[i];
+                const b = triangleIndices[i + 1];
+                const c = triangleIndices[i + 2];
+                const k0 = this.packEdge(a, b);
+                const n0 = (counts.get(k0) ?? 0) + 1;
+                counts.set(k0, n0);
+                if (n0 === 1)
+                    oriented.set(k0, [a, b]);
+                const k1 = this.packEdge(b, c);
+                const n1 = (counts.get(k1) ?? 0) + 1;
+                counts.set(k1, n1);
+                if (n1 === 1)
+                    oriented.set(k1, [b, c]);
+                const k2 = this.packEdge(c, a);
+                const n2 = (counts.get(k2) ?? 0) + 1;
+                counts.set(k2, n2);
+                if (n2 === 1)
+                    oriented.set(k2, [c, a]);
+            }
+            boundaryEdges = [];
+            for (const [key, count] of counts) {
+                if (count !== 1)
+                    continue;
+                const edge = oriented.get(key);
+                if (edge)
+                    boundaryEdges.push(edge);
             }
         }
-        const sideVertexCount = depth === 0 ? 0 : sideSegments * 4;
+        const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
+        const sideVertexCount = depth === 0 ? 0 : sideEdgeCount * 4;
         const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
         const vertexCount = baseVertexCount + sideVertexCount;
         const vertices = new Float32Array(vertexCount * 3);
         const normals = new Float32Array(vertexCount * 3);
         const indexCount = depth === 0
             ? triangleIndices.length
-            : triangleIndices.length * 2 + sideSegments * 6;
+            : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
             // Single-sided flat geometry at z=0
@@ -3022,60 +3036,62 @@ class Extruder {
         // Side walls
         let nextVertex = numPoints * 2;
         let idxPos = triangleIndices.length * 2;
-        for (const contour of geometry.contours) {
-            for (let i = 0; i < contour.length - 2; i += 2) {
-                const p0x = contour[i];
-                const p0y = contour[i + 1];
-                const p1x = contour[i + 2];
-                const p1y = contour[i + 3];
-                // Perpendicular normal for this wall segment
-                const ex = p1x - p0x;
-                const ey = p1y - p0y;
-                const lenSq = ex * ex + ey * ey;
-                let nx = 0;
-                let ny = 0;
-                if (lenSq > 0) {
-                    const invLen = 1 / Math.sqrt(lenSq);
-                    nx = ey * invLen;
-                    ny = -ex * invLen;
-                }
-                const baseVertex = nextVertex;
-                const base = baseVertex * 3;
-                // Wall quad: front edge at z=0, back edge at z=depth
-                vertices[base] = p0x;
-                vertices[base + 1] = p0y;
-                vertices[base + 2] = 0;
-                vertices[base + 3] = p1x;
-                vertices[base + 4] = p1y;
-                vertices[base + 5] = 0;
-                vertices[base + 6] = p0x;
-                vertices[base + 7] = p0y;
-                vertices[base + 8] = backZ;
-                vertices[base + 9] = p1x;
-                vertices[base + 10] = p1y;
-                vertices[base + 11] = backZ;
-                // Wall normals point perpendicular to edge
-                normals[base] = nx;
-                normals[base + 1] = ny;
-                normals[base + 2] = 0;
-                normals[base + 3] = nx;
-                normals[base + 4] = ny;
-                normals[base + 5] = 0;
-                normals[base + 6] = nx;
-                normals[base + 7] = ny;
-                normals[base + 8] = 0;
-                normals[base + 9] = nx;
-                normals[base + 10] = ny;
-                normals[base + 11] = 0;
-                // Two triangles per wall segment
-                indices[idxPos++] = baseVertex;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 2;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 3;
-                indices[idxPos++] = baseVertex + 2;
-                nextVertex += 4;
-            }
+        for (let e = 0; e < boundaryEdges.length; e++) {
+            const [u, v] = boundaryEdges[e];
+            const u2 = u * 2;
+            const v2 = v * 2;
+            const p0x = points[u2];
+            const p0y = points[u2 + 1];
+            const p1x = points[v2];
+            const p1y = points[v2 + 1];
+            // Perpendicular normal for this wall segment
+            // Uses the edge direction from the cap triangulation so winding does not depend on contour direction
+            const ex = p1x - p0x;
+            const ey = p1y - p0y;
+            const lenSq = ex * ex + ey * ey;
+            let nx = 0;
+            let ny = 0;
+            if (lenSq > 0) {
+                const invLen = 1 / Math.sqrt(lenSq);
+                nx = ey * invLen;
+                ny = -ex * invLen;
+            }
+            const baseVertex = nextVertex;
+            const base = baseVertex * 3;
+            // Wall quad: front edge at z=0, back edge at z=depth
+            vertices[base] = p0x;
+            vertices[base + 1] = p0y;
+            vertices[base + 2] = 0;
+            vertices[base + 3] = p1x;
+            vertices[base + 4] = p1y;
+            vertices[base + 5] = 0;
+            vertices[base + 6] = p0x;
+            vertices[base + 7] = p0y;
+            vertices[base + 8] = backZ;
+            vertices[base + 9] = p1x;
+            vertices[base + 10] = p1y;
+            vertices[base + 11] = backZ;
+            // Wall normals point perpendicular to edge
+            normals[base] = nx;
+            normals[base + 1] = ny;
+            normals[base + 2] = 0;
+            normals[base + 3] = nx;
+            normals[base + 4] = ny;
+            normals[base + 5] = 0;
+            normals[base + 6] = nx;
+            normals[base + 7] = ny;
+            normals[base + 8] = 0;
+            normals[base + 9] = nx;
+            normals[base + 10] = ny;
+            normals[base + 11] = 0;
+            // Two triangles per wall segment
+            indices[idxPos++] = baseVertex;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 2;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 3;
+            indices[idxPos++] = baseVertex + 2;
+            nextVertex += 4;
         }
         return { vertices, normals, indices };
     }
@@ -4174,7 +4190,7 @@ class GlyphGeometryBuilder {
                 // Use glyph-level caching when separateGlyphs is set or when cluster contains colored text
                 const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
                 // Iterate over the geometric groups identified by BoundaryClusterer
-                // logical groups (words) split into geometric sub-groups (e.g. "aa", "XX", "bb")
+                // logical groups (words) split into geometric sub-groups
                 for (const groupIndices of boundaryGroups) {
                     const isOverlappingGroup = groupIndices.length > 1;
                     const shouldCluster = isOverlappingGroup && !forceSeparate;