three-text 0.2.17 → 0.2.18

package/dist/index.umd.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
@@ -2731,7 +2731,9 @@
                 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');
@@ -2753,24 +2755,6 @@
             }
             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
@@ -2952,28 +2936,58 @@
 
     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
@@ -3029,60 +3043,62 @@
             // 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 };
         }
@@ -4181,7 +4197,7 @@
                     // 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;