three-text 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.1.1
+ * three-text v0.2.0
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -11,8 +11,6 @@
  * 
  * This software includes third-party code - see LICENSE_THIRD_PARTY for details.
  */
-import { Vector2, Vector3, BufferGeometry, Float32BufferAttribute, Box3 } from 'three';
-
 // Cached flag check at module load time for zero-cost logging
 const isLogEnabled = (() => {
     if (typeof window !== 'undefined' && window.THREE_TEXT_LOG) {
@@ -202,7 +200,7 @@ class ActiveNodeList {
         this.allNodes = new Set();
     }
     getKey(position, fitness) {
-        return `${position}_${fitness}`;
+        return (position << 2) | fitness;
     }
     insert(node) {
         const key = this.getKey(node.position, node.fitness);
@@ -1254,7 +1252,7 @@ class TextLayout {
         }
         return { lines };
     }
-    applyAlignment(geometry, options) {
+    applyAlignment(vertices, options) {
         const { width, align, planeBounds } = options;
         let offset = 0;
         const adjustedBounds = {
@@ -1270,7 +1268,10 @@ class TextLayout {
                 offset = width - planeBounds.max.x;
             }
             if (offset !== 0) {
-                geometry.translate(offset, 0, 0);
+                // Translate vertices directly
+                for (let i = 0; i < vertices.length; i += 3) {
+                    vertices[i] += offset;
+                }
                 adjustedBounds.min.x += offset;
                 adjustedBounds.max.x += offset;
             }
@@ -1723,6 +1724,268 @@ async function loadPattern(language, patternsPath) {
     }
 }
 
+// Bector and bounding box types for core
+// 2D Vector
+class Vec2 {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    clone() {
+        return new Vec2(this.x, this.y);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return dx * dx + dy * dy;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y;
+    }
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+}
+// 3D Vector
+class Vec3 {
+    constructor(x = 0, y = 0, z = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    set(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    clone() {
+        return new Vec3(this.x, this.y, this.z);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        this.z /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+    cross(v) {
+        const x = this.y * v.z - this.z * v.y;
+        const y = this.z * v.x - this.x * v.z;
+        const z = this.x * v.y - this.y * v.x;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y && this.z === v.z;
+    }
+}
+// 3D Bounding Box
+class Box3 {
+    constructor(min = new Vec3(Infinity, Infinity, Infinity), max = new Vec3(-Infinity, -Infinity, -Infinity)) {
+        this.min = min;
+        this.max = max;
+    }
+    set(min, max) {
+        this.min.copy(min);
+        this.max.copy(max);
+        return this;
+    }
+    setFromPoints(points) {
+        this.makeEmpty();
+        for (let i = 0; i < points.length; i++) {
+            this.expandByPoint(points[i]);
+        }
+        return this;
+    }
+    makeEmpty() {
+        this.min.x = this.min.y = this.min.z = Infinity;
+        this.max.x = this.max.y = this.max.z = -Infinity;
+        return this;
+    }
+    isEmpty() {
+        return (this.max.x < this.min.x ||
+            this.max.y < this.min.y ||
+            this.max.z < this.min.z);
+    }
+    expandByPoint(point) {
+        this.min.x = Math.min(this.min.x, point.x);
+        this.min.y = Math.min(this.min.y, point.y);
+        this.min.z = Math.min(this.min.z, point.z);
+        this.max.x = Math.max(this.max.x, point.x);
+        this.max.y = Math.max(this.max.y, point.y);
+        this.max.z = Math.max(this.max.z, point.z);
+        return this;
+    }
+    expandByScalar(scalar) {
+        this.min.x -= scalar;
+        this.min.y -= scalar;
+        this.min.z -= scalar;
+        this.max.x += scalar;
+        this.max.y += scalar;
+        this.max.z += scalar;
+        return this;
+    }
+    containsPoint(point) {
+        return (point.x >= this.min.x &&
+            point.x <= this.max.x &&
+            point.y >= this.min.y &&
+            point.y <= this.max.y &&
+            point.z >= this.min.z &&
+            point.z <= this.max.z);
+    }
+    containsBox(box) {
+        return (this.min.x <= box.min.x &&
+            box.max.x <= this.max.x &&
+            this.min.y <= box.min.y &&
+            box.max.y <= this.max.y &&
+            this.min.z <= box.min.z &&
+            box.max.z <= this.max.z);
+    }
+    intersectsBox(box) {
+        return (box.max.x >= this.min.x &&
+            box.min.x <= this.max.x &&
+            box.max.y >= this.min.y &&
+            box.min.y <= this.max.y &&
+            box.max.z >= this.min.z &&
+            box.min.z <= this.max.z);
+    }
+    getCenter(target = new Vec3()) {
+        return this.isEmpty()
+            ? target.set(0, 0, 0)
+            : target.set((this.min.x + this.max.x) * 0.5, (this.min.y + this.max.y) * 0.5, (this.min.z + this.max.z) * 0.5);
+    }
+    getSize(target = new Vec3()) {
+        return this.isEmpty()
+            ? target.set(0, 0, 0)
+            : target.set(this.max.x - this.min.x, this.max.y - this.min.y, this.max.z - this.min.z);
+    }
+    clone() {
+        return new Box3(this.min.clone(), this.max.clone());
+    }
+    copy(box) {
+        this.min.copy(box.min);
+        this.max.copy(box.max);
+        return this;
+    }
+    union(box) {
+        this.min.x = Math.min(this.min.x, box.min.x);
+        this.min.y = Math.min(this.min.y, box.min.y);
+        this.min.z = Math.min(this.min.z, box.min.z);
+        this.max.x = Math.max(this.max.x, box.max.x);
+        this.max.y = Math.max(this.max.y, box.max.y);
+        this.max.z = Math.max(this.max.z, box.max.z);
+        return this;
+    }
+    equals(box) {
+        return box.min.equals(this.min) && box.max.equals(this.max);
+    }
+}
+
 var WINDING;
 (function (WINDING) {
     WINDING[WINDING["ODD"] = 0] = "ODD";
@@ -3943,8 +4206,8 @@ class Extruder {
             const p0y = points[i + 1];
             const p1x = points[i + 2];
             const p1y = points[i + 3];
-            const edge = new Vector2(p1x - p0x, p1y - p0y);
-            const normal = new Vector2(edge.y, -edge.x).normalize();
+            const edge = new Vec2(p1x - p0x, p1y - p0y);
+            const normal = new Vec2(edge.y, -edge.x).normalize();
             const wallBaseIndex = vertices.length / 3;
             vertices.push(p0x, p0y, 0, p1x, p1y, 0, p0x, p0y, depth, p1x, p1y, depth);
             normals.push(normal.x, normal.y, 0, normal.x, normal.y, 0, normal.x, normal.y, 0, normal.x, normal.y, 0);
@@ -4254,8 +4517,8 @@ class PathOptimizer {
             const prev = points[i - 1];
             const current = points[i];
             const next = points[i + 1];
-            const v1 = new Vector2(current.x - prev.x, current.y - prev.y);
-            const v2 = new Vector2(next.x - current.x, next.y - current.y);
+            const v1 = new Vec2(current.x - prev.x, current.y - prev.y);
+            const v2 = new Vec2(next.x - current.x, next.y - current.y);
             const angle = Math.abs(v1.angle() - v2.angle());
             const normalizedAngle = Math.min(angle, 2 * Math.PI - angle);
             if (normalizedAngle > threshold ||
@@ -4369,12 +4632,9 @@ class Polygonizer {
         const dx = x3 - x1;
         const dy = y3 - y1;
         const d = Math.abs((x2 - x3) * dy - (y2 - y3) * dx);
-        const curveLength = Math.sqrt(dx * dx + dy * dy);
         const baseTolerance = this.curveFidelityConfig.distanceTolerance ??
             DEFAULT_CURVE_FIDELITY.distanceTolerance;
-        const distanceTolerance = curveLength > 0
-            ? baseTolerance * baseTolerance
-            : baseTolerance * baseTolerance;
+        const distanceTolerance = baseTolerance * baseTolerance;
         if (d > COLLINEARITY_EPSILON) {
             // Regular case
             // Recursion terminates when the curve is flat enough (deviation from straight line is within tolerance)
@@ -4439,12 +4699,9 @@ class Polygonizer {
         const dy = y4 - y1;
         const d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx);
         const d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx);
-        const curveLength = Math.sqrt(dx * dx + dy * dy);
         const baseTolerance = this.curveFidelityConfig.distanceTolerance ??
             DEFAULT_CURVE_FIDELITY.distanceTolerance;
-        const distanceTolerance = curveLength > 0
-            ? baseTolerance * baseTolerance
-            : baseTolerance * baseTolerance;
+        const distanceTolerance = baseTolerance * baseTolerance;
         let switchCondition = 0;
         if (d2 > COLLINEARITY_EPSILON)
             switchCondition |= 1;
@@ -4552,7 +4809,7 @@ class Polygonizer {
         this.recursiveCubic(x1234, y1234, x234, y234, x34, y34, x4, y4, points, level + 1);
     }
     addPoint(x, y, points) {
-        const newPoint = new Vector2(x, y);
+        const newPoint = new Vec2(x, y);
         if (points.length === 0) {
             points.push(newPoint);
             return;
@@ -4575,13 +4832,13 @@ class GlyphContourCollector {
         this.currentPath = null;
         this.currentPoint = null;
         this.currentGlyphBounds = {
-            min: new Vector2(Infinity, Infinity),
-            max: new Vector2(-Infinity, -Infinity)
+            min: new Vec2(Infinity, Infinity),
+            max: new Vec2(-Infinity, -Infinity)
         };
         this.collectedGlyphs = [];
         this.glyphPositions = [];
         this.glyphTextIndices = [];
-        this.currentPosition = new Vector2(0, 0);
+        this.currentPosition = new Vec2(0, 0);
         this.polygonizer = new Polygonizer(curveFidelityConfig);
         this.pathOptimizer = new PathOptimizer({
             ...DEFAULT_OPTIMIZATION_CONFIG,
@@ -4636,7 +4893,7 @@ class GlyphContourCollector {
         if (this.currentPath) {
             this.finishPath();
         }
-        this.currentPoint = new Vector2(x, y);
+        this.currentPoint = new Vec2(x, y);
         this.updateBounds(this.currentPoint);
         this.currentPath = {
             points: [this.currentPoint],
@@ -4646,7 +4903,7 @@ class GlyphContourCollector {
     onLineTo(x, y) {
         if (!this.currentPath || !this.currentPoint)
             return;
-        const point = new Vector2(x, y);
+        const point = new Vec2(x, y);
         this.updateBounds(point);
         this.currentPath.points.push(point);
         this.currentPoint = point;
@@ -4655,8 +4912,8 @@ class GlyphContourCollector {
         if (!this.currentPath || !this.currentPoint)
             return;
         const start = this.currentPoint;
-        const control = new Vector2(cx, cy);
-        const end = new Vector2(x, y);
+        const control = new Vec2(cx, cy);
+        const end = new Vec2(x, y);
         const dx = end.x - start.x;
         const dy = end.y - start.y;
         const d = Math.abs((control.x - end.x) * dy - (control.y - end.y) * dx);
@@ -4677,9 +4934,9 @@ class GlyphContourCollector {
         if (!this.currentPath || !this.currentPoint)
             return;
         const start = this.currentPoint;
-        const control1 = new Vector2(c1x, c1y);
-        const control2 = new Vector2(c2x, c2y);
-        const end = new Vector2(x, y);
+        const control1 = new Vec2(c1x, c1y);
+        const control2 = new Vec2(c2x, c2y);
+        const end = new Vec2(x, y);
         const dx = end.x - start.x;
         const dy = end.y - start.y;
         const d1 = Math.abs((control1.x - end.x) * dy - (control1.y - end.y) * dx);
@@ -4721,7 +4978,7 @@ class GlyphContourCollector {
         this.currentGlyphBounds.max.y = Math.max(this.currentGlyphBounds.max.y, point.y);
     }
     getCollectedGlyphs() {
-        // Make sure to finish any pending glyph
+        // Finish any pending glyph
         if (this.currentGlyphPaths.length > 0) {
             this.finishGlyph();
         }
@@ -4744,8 +5001,8 @@ class GlyphContourCollector {
         this.currentTextIndex = 0;
         this.currentPosition.set(0, 0);
         this.currentGlyphBounds = {
-            min: new Vector2(Infinity, Infinity),
-            max: new Vector2(-Infinity, -Infinity)
+            min: new Vec2(Infinity, Infinity),
+            max: new Vec2(-Infinity, -Infinity)
         };
     }
     setCurveFidelityConfig(config) {
@@ -4914,7 +5171,7 @@ class GlyphGeometryBuilder {
                     clusterGlyphContours.push(this.getContoursForGlyph(glyph.g));
                 }
                 // Step 2: Check for overlaps within the cluster
-                const relativePositions = cluster.glyphs.map((g) => new Vector3(g.x, g.y, 0));
+                const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x, g.y, 0));
                 const boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
                 const hasOverlaps = separateGlyphs
                     ? false
@@ -4931,7 +5188,7 @@ class GlyphGeometryBuilder {
                             for (const path of glyphContours.paths) {
                                 clusterPaths.push({
                                     ...path,
-                                    points: path.points.map((p) => new Vector2(p.x + (glyph.x ?? 0), p.y + (glyph.y ?? 0)))
+                                    points: path.points.map((p) => new Vec2(p.x + (glyph.x ?? 0), p.y + (glyph.y ?? 0)))
                                 });
                             }
                         }
@@ -4944,7 +5201,7 @@ class GlyphGeometryBuilder {
                     for (let i = 0; i < cluster.glyphs.length; i++) {
                         const glyph = cluster.glyphs[i];
                         const glyphContours = clusterGlyphContours[i];
-                        const absoluteGlyphPosition = new Vector3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
+                        const absoluteGlyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
                         const glyphInfo = this.createGlyphInfo(glyph, vertexOffset, clusterVertexCount, absoluteGlyphPosition, glyphContours, depth);
                         glyphInfos.push(glyphInfo);
                         this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
@@ -4955,7 +5212,7 @@ class GlyphGeometryBuilder {
                     for (let i = 0; i < cluster.glyphs.length; i++) {
                         const glyph = cluster.glyphs[i];
                         const glyphContours = clusterGlyphContours[i];
-                        const glyphPosition = new Vector3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
+                        const glyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
                         // Skip glyphs with no paths (spaces, zero-width characters, etc.)
                         if (glyphContours.paths.length === 0) {
                             const glyphInfo = this.createGlyphInfo(glyph, 0, 0, glyphPosition, glyphContours, depth);
@@ -4976,15 +5233,17 @@ class GlyphGeometryBuilder {
                 }
             }
         }
-        const geometry = new BufferGeometry();
         const vertexArray = new Float32Array(vertices);
         const normalArray = new Float32Array(normals);
-        geometry.setAttribute('position', new Float32BufferAttribute(vertexArray, 3));
-        geometry.setAttribute('normal', new Float32BufferAttribute(normalArray, 3));
-        geometry.setIndex(indices);
-        geometry.computeBoundingBox();
+        const indexArray = new Uint32Array(indices);
         perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
-        return { geometry, glyphInfos, planeBounds };
+        return {
+            vertices: vertexArray,
+            normals: normalArray,
+            indices: indexArray,
+            glyphInfos,
+            planeBounds
+        };
     }
     appendGeometry(vertices, normals, indices, data, position, offset) {
         for (let j = 0; j < data.vertices.length; j += 3) {
@@ -5042,19 +5301,34 @@ class GlyphGeometryBuilder {
     }
     extrudeAndPackage(processedGeometry, depth) {
         const extrudedResult = this.extruder.extrude(processedGeometry, depth, this.loadedFont.upem);
-        const tempGeometry = new BufferGeometry();
-        const vertices = new Float32Array(extrudedResult.vertices);
-        tempGeometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
-        tempGeometry.computeBoundingBox();
-        const bounds = tempGeometry.boundingBox;
-        const boundsMin = new Vector3(bounds.min.x, bounds.min.y, bounds.min.z);
-        const boundsMax = new Vector3(bounds.max.x, bounds.max.y, bounds.max.z);
-        tempGeometry.dispose();
+        // Compute bounding box from vertices
+        const vertices = extrudedResult.vertices;
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        for (let i = 0; i < vertices.length; i += 3) {
+            const x = vertices[i];
+            const y = vertices[i + 1];
+            const z = vertices[i + 2];
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+            if (z < minZ)
+                minZ = z;
+            if (z > maxZ)
+                maxZ = z;
+        }
+        const boundsMin = new Vec3(minX, minY, minZ);
+        const boundsMax = new Vec3(maxX, maxY, maxZ);
         const vertexCount = extrudedResult.vertices.length / 3;
         const IndexArray = vertexCount < 65536 ? Uint16Array : Uint32Array;
         return {
             geometry: processedGeometry,
-            vertices: vertices,
+            vertices: new Float32Array(extrudedResult.vertices),
             normals: new Float32Array(extrudedResult.normals),
             indices: new IndexArray(extrudedResult.indices),
             bounds: { min: boundsMin, max: boundsMax },
@@ -5071,8 +5345,8 @@ class GlyphGeometryBuilder {
         return this.extrudeAndPackage(processedGeometry, depth);
     }
     updatePlaneBounds(glyphBounds, planeBounds) {
-        const planeBox = new Box3(new Vector3(planeBounds.min.x, planeBounds.min.y, planeBounds.min.z), new Vector3(planeBounds.max.x, planeBounds.max.y, planeBounds.max.z));
-        const glyphBox = new Box3(new Vector3(glyphBounds.min.x, glyphBounds.min.y, glyphBounds.min.z), new Vector3(glyphBounds.max.x, glyphBounds.max.y, glyphBounds.max.z));
+        const planeBox = new Box3(new Vec3(planeBounds.min.x, planeBounds.min.y, planeBounds.min.z), new Vec3(planeBounds.max.x, planeBounds.max.y, planeBounds.max.z));
+        const glyphBox = new Box3(new Vec3(glyphBounds.min.x, glyphBounds.min.y, glyphBounds.min.z), new Vec3(glyphBounds.max.x, glyphBounds.max.y, glyphBounds.max.z));
         planeBox.union(glyphBox);
         planeBounds.min.x = planeBox.min.x;
         planeBounds.min.y = planeBox.min.y;
@@ -5137,8 +5411,8 @@ class TextShaper {
         const clusters = [];
         let currentClusterGlyphs = [];
         let currentClusterText = '';
-        let clusterStartPosition = new Vector3();
-        let cursor = new Vector3(lineInfo.xOffset, -lineIndex * scaledLineHeight, 0);
+        let clusterStartPosition = new Vec3();
+        let cursor = new Vec3(lineInfo.xOffset, -lineIndex * scaledLineHeight, 0);
         const letterSpacingFU = letterSpacing * this.loadedFont.upem;
         const spaceAdjustment = this.calculateSpaceAdjustment(lineInfo, align, letterSpacing);
         for (let i = 0; i < glyphInfos.length; i++) {
@@ -5168,7 +5442,7 @@ class TextShaper {
             }
             const absoluteGlyphPosition = cursor
                 .clone()
-                .add(new Vector3(glyph.dx, glyph.dy, 0));
+                .add(new Vec3(glyph.dx, glyph.dy, 0));
             if (!isWhitespace) {
                 if (currentClusterGlyphs.length === 0) {
                     clusterStartPosition.copy(absoluteGlyphPosition);
@@ -5301,7 +5575,7 @@ class GlyphCache {
         size += glyph.normals.length * 4;
         // Indices (Uint16Array or Uint32Array)
         size += glyph.indices.length * glyph.indices.BYTES_PER_ELEMENT;
-        // Bounds (2 Vector3s = 6 floats * 4 bytes)
+        // Bounds (2 Vec3s = 6 floats * 4 bytes)
         size += 24;
         // Object overhead
         size += 256;
@@ -6119,7 +6393,7 @@ class TextRangeQuery {
         }
         const box = new Box3();
         for (const glyph of glyphs) {
-            const glyphBox = new Box3(new Vector3(glyph.bounds.min.x, glyph.bounds.min.y, glyph.bounds.min.z), new Vector3(glyph.bounds.max.x, glyph.bounds.max.y, glyph.bounds.max.z));
+            const glyphBox = new Box3(new Vec3(glyph.bounds.min.x, glyph.bounds.min.y, glyph.bounds.min.z), new Vec3(glyph.bounds.max.x, glyph.bounds.max.y, glyph.bounds.max.z));
             box.union(glyphBox);
         }
         return {
@@ -6150,7 +6424,7 @@ class Text {
         HarfBuzzLoader.setWasmBuffer(wasmBuffer);
         Text.hbInitPromise = null;
     }
-    // Initialize HarfBuzz WASM manually (optional - called automatically by create())
+    // Initialize HarfBuzz WASM (optional - create() calls this if needed)
     static init() {
         if (!Text.hbInitPromise) {
             Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
@@ -6284,9 +6558,10 @@ class Text {
             const clustersByLine = this.textShaper.shapeLines(layoutData.lines, layoutData.scaledLineHeight, layoutData.letterSpacing, layoutData.align, layoutData.direction, options.color, options.text);
             const shapedResult = this.geometryBuilder.buildInstancedGeometry(clustersByLine, layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, options.separateGlyphsWithAttributes || false);
             const cacheStats = this.geometryBuilder.getCacheStats();
-            const result = this.finalizeGeometry(shapedResult.geometry, shapedResult.glyphInfos, shapedResult.planeBounds, options, cacheStats, options.text);
+            const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, cacheStats, options.text);
             if (options.separateGlyphsWithAttributes) {
-                this.addGlyphAttributes(result.geometry, result.glyphs);
+                const glyphAttrs = this.createGlyphAttributes(result.vertices.length / 3, result.glyphs);
+                result.glyphAttributes = glyphAttrs;
             }
             return result;
         }
@@ -6398,8 +6673,8 @@ class Text {
             size
         };
     }
-    applyColorSystem(geometry, glyphInfoArray, color, originalText) {
-        const vertexCount = geometry.attributes.position.count;
+    applyColorSystem(vertices, glyphInfoArray, color, originalText) {
+        const vertexCount = vertices.length / 3;
         const colors = new Float32Array(vertexCount * 3);
         const coloredRanges = [];
         // Simple case: array color for all text
@@ -6489,16 +6764,15 @@ class Text {
                 });
             }
         }
-        geometry.setAttribute('color', new Float32BufferAttribute(colors, 3));
-        return coloredRanges;
+        return { colors, coloredRanges };
     }
-    finalizeGeometry(geometry, glyphInfoArray, planeBounds, options, cacheStats, originalText) {
+    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, cacheStats, originalText) {
         const { layout = {}, size = 72 } = options;
         const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
         if (!this.textLayout) {
             this.textLayout = new TextLayout(this.loadedFont);
         }
-        const alignmentResult = this.textLayout.applyAlignment(geometry, {
+        const alignmentResult = this.textLayout.applyAlignment(vertices, {
             width,
             align,
             planeBounds
@@ -6507,7 +6781,13 @@ class Text {
         planeBounds.min.x = alignmentResult.adjustedBounds.min.x;
         planeBounds.max.x = alignmentResult.adjustedBounds.max.x;
         const finalScale = size / this.loadedFont.upem;
-        geometry.scale(finalScale, finalScale, finalScale);
+        // Scale vertices and normals directly
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] *= finalScale;
+        }
+        for (let i = 0; i < normals.length; i++) {
+            normals[i] *= finalScale;
+        }
         planeBounds.min.x *= finalScale;
         planeBounds.min.y *= finalScale;
         planeBounds.min.z *= finalScale;
@@ -6527,15 +6807,22 @@ class Text {
             glyphInfo.bounds.max.y *= finalScale;
             glyphInfo.bounds.max.z *= finalScale;
         }
-        const coloredRanges = options.color
-            ? this.applyColorSystem(geometry, glyphInfoArray, options.color, options.text)
-            : undefined;
+        let colors;
+        let coloredRanges;
+        if (options.color) {
+            const colorResult = this.applyColorSystem(vertices, glyphInfoArray, options.color, options.text);
+            colors = colorResult.colors;
+            coloredRanges = colorResult.coloredRanges;
+        }
         // Collect optimization stats for return value
         const optimizationStats = this.geometryBuilder.getOptimizationStats();
-        const trianglesGenerated = geometry.index ? geometry.index.count / 3 : 0;
-        const verticesGenerated = geometry.attributes.position.count;
+        const trianglesGenerated = indices.length / 3;
+        const verticesGenerated = vertices.length / 3;
         return {
-            geometry,
+            vertices,
+            normals,
+            indices,
+            colors,
             glyphs: glyphInfoArray,
             planeBounds,
             stats: {
@@ -6553,7 +6840,8 @@ class Text {
                 const queryInstance = new TextRangeQuery(originalText, glyphInfoArray);
                 return queryInstance.execute(options);
             },
-            coloredRanges
+            coloredRanges,
+            glyphAttributes: undefined
         };
     }
     getFontMetrics() {
@@ -6598,8 +6886,7 @@ class Text {
             this.geometryBuilder.clearCache();
         }
     }
-    addGlyphAttributes(geometry, glyphs) {
-        const vertexCount = geometry.attributes.position.count;
+    createGlyphAttributes(vertexCount, glyphs) {
         const glyphCenters = new Float32Array(vertexCount * 3);
         const glyphIndices = new Float32Array(vertexCount);
         const glyphLineIndices = new Float32Array(vertexCount);
@@ -6618,9 +6905,11 @@ class Text {
                 }
             }
         });
-        geometry.setAttribute('glyphCenter', new Float32BufferAttribute(glyphCenters, 3));
-        geometry.setAttribute('glyphIndex', new Float32BufferAttribute(glyphIndices, 1));
-        geometry.setAttribute('glyphLineIndex', new Float32BufferAttribute(glyphLineIndices, 1));
+        return {
+            glyphCenter: glyphCenters,
+            glyphIndex: glyphIndices,
+            glyphLineIndex: glyphLineIndices
+        };
     }
     destroy() {
         if (!this.loadedFont) {