three-text 0.1.1 → 0.2.0

package/dist/index.umd.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
@@ -12,10 +12,10 @@
  * This software includes third-party code - see LICENSE_THIRD_PARTY for details.
  */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('three')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'three'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ThreeText = {}, global.THREE));
-})(this, (function (exports, three) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ThreeText = {}));
+})(this, (function (exports) {
     // Cached flag check at module load time for zero-cost logging
     const isLogEnabled = (() => {
         if (typeof window !== 'undefined' && window.THREE_TEXT_LOG) {
@@ -205,7 +205,7 @@
             this.allNodes = new Set();
         }
         getKey(position, fitness) {
-            return `${position}_${fitness}`;
+            return (position << 2) | fitness;
         }
         insert(node) {
             const key = this.getKey(node.position, node.fitness);
@@ -1257,7 +1257,7 @@
             }
             return { lines };
         }
-        applyAlignment(geometry, options) {
+        applyAlignment(vertices, options) {
             const { width, align, planeBounds } = options;
             let offset = 0;
             const adjustedBounds = {
@@ -1273,7 +1273,10 @@
                     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;
                 }
@@ -1728,6 +1731,268 @@
         }
     }
 
+    // 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";
@@ -3948,8 +4213,8 @@
                 const p0y = points[i + 1];
                 const p1x = points[i + 2];
                 const p1y = points[i + 3];
-                const edge = new three.Vector2(p1x - p0x, p1y - p0y);
-                const normal = new three.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);
@@ -4259,8 +4524,8 @@
                 const prev = points[i - 1];
                 const current = points[i];
                 const next = points[i + 1];
-                const v1 = new three.Vector2(current.x - prev.x, current.y - prev.y);
-                const v2 = new three.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 ||
@@ -4374,12 +4639,9 @@
             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)
@@ -4444,12 +4706,9 @@
             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;
@@ -4557,7 +4816,7 @@
             this.recursiveCubic(x1234, y1234, x234, y234, x34, y34, x4, y4, points, level + 1);
         }
         addPoint(x, y, points) {
-            const newPoint = new three.Vector2(x, y);
+            const newPoint = new Vec2(x, y);
             if (points.length === 0) {
                 points.push(newPoint);
                 return;
@@ -4580,13 +4839,13 @@
             this.currentPath = null;
             this.currentPoint = null;
             this.currentGlyphBounds = {
-                min: new three.Vector2(Infinity, Infinity),
-                max: new three.Vector2(-Infinity, -Infinity)
+                min: new Vec2(Infinity, Infinity),
+                max: new Vec2(-Infinity, -Infinity)
             };
             this.collectedGlyphs = [];
             this.glyphPositions = [];
             this.glyphTextIndices = [];
-            this.currentPosition = new three.Vector2(0, 0);
+            this.currentPosition = new Vec2(0, 0);
             this.polygonizer = new Polygonizer(curveFidelityConfig);
             this.pathOptimizer = new PathOptimizer({
                 ...DEFAULT_OPTIMIZATION_CONFIG,
@@ -4641,7 +4900,7 @@
             if (this.currentPath) {
                 this.finishPath();
             }
-            this.currentPoint = new three.Vector2(x, y);
+            this.currentPoint = new Vec2(x, y);
             this.updateBounds(this.currentPoint);
             this.currentPath = {
                 points: [this.currentPoint],
@@ -4651,7 +4910,7 @@
         onLineTo(x, y) {
             if (!this.currentPath || !this.currentPoint)
                 return;
-            const point = new three.Vector2(x, y);
+            const point = new Vec2(x, y);
             this.updateBounds(point);
             this.currentPath.points.push(point);
             this.currentPoint = point;
@@ -4660,8 +4919,8 @@
             if (!this.currentPath || !this.currentPoint)
                 return;
             const start = this.currentPoint;
-            const control = new three.Vector2(cx, cy);
-            const end = new three.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);
@@ -4682,9 +4941,9 @@
             if (!this.currentPath || !this.currentPoint)
                 return;
             const start = this.currentPoint;
-            const control1 = new three.Vector2(c1x, c1y);
-            const control2 = new three.Vector2(c2x, c2y);
-            const end = new three.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);
@@ -4726,7 +4985,7 @@
             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();
             }
@@ -4749,8 +5008,8 @@
             this.currentTextIndex = 0;
             this.currentPosition.set(0, 0);
             this.currentGlyphBounds = {
-                min: new three.Vector2(Infinity, Infinity),
-                max: new three.Vector2(-Infinity, -Infinity)
+                min: new Vec2(Infinity, Infinity),
+                max: new Vec2(-Infinity, -Infinity)
             };
         }
         setCurveFidelityConfig(config) {
@@ -4919,7 +5178,7 @@
                         clusterGlyphContours.push(this.getContoursForGlyph(glyph.g));
                     }
                     // Step 2: Check for overlaps within the cluster
-                    const relativePositions = cluster.glyphs.map((g) => new three.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
@@ -4936,7 +5195,7 @@
                                 for (const path of glyphContours.paths) {
                                     clusterPaths.push({
                                         ...path,
-                                        points: path.points.map((p) => new three.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)))
                                     });
                                 }
                             }
@@ -4949,7 +5208,7 @@
                         for (let i = 0; i < cluster.glyphs.length; i++) {
                             const glyph = cluster.glyphs[i];
                             const glyphContours = clusterGlyphContours[i];
-                            const absoluteGlyphPosition = new three.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);
@@ -4960,7 +5219,7 @@
                         for (let i = 0; i < cluster.glyphs.length; i++) {
                             const glyph = cluster.glyphs[i];
                             const glyphContours = clusterGlyphContours[i];
-                            const glyphPosition = new three.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);
@@ -4981,15 +5240,17 @@
                     }
                 }
             }
-            const geometry = new three.BufferGeometry();
             const vertexArray = new Float32Array(vertices);
             const normalArray = new Float32Array(normals);
-            geometry.setAttribute('position', new three.Float32BufferAttribute(vertexArray, 3));
-            geometry.setAttribute('normal', new three.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) {
@@ -5047,19 +5308,34 @@
         }
         extrudeAndPackage(processedGeometry, depth) {
             const extrudedResult = this.extruder.extrude(processedGeometry, depth, this.loadedFont.upem);
-            const tempGeometry = new three.BufferGeometry();
-            const vertices = new Float32Array(extrudedResult.vertices);
-            tempGeometry.setAttribute('position', new three.Float32BufferAttribute(vertices, 3));
-            tempGeometry.computeBoundingBox();
-            const bounds = tempGeometry.boundingBox;
-            const boundsMin = new three.Vector3(bounds.min.x, bounds.min.y, bounds.min.z);
-            const boundsMax = new three.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 },
@@ -5076,8 +5352,8 @@
             return this.extrudeAndPackage(processedGeometry, depth);
         }
         updatePlaneBounds(glyphBounds, planeBounds) {
-            const planeBox = new three.Box3(new three.Vector3(planeBounds.min.x, planeBounds.min.y, planeBounds.min.z), new three.Vector3(planeBounds.max.x, planeBounds.max.y, planeBounds.max.z));
-            const glyphBox = new three.Box3(new three.Vector3(glyphBounds.min.x, glyphBounds.min.y, glyphBounds.min.z), new three.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;
@@ -5142,8 +5418,8 @@
             const clusters = [];
             let currentClusterGlyphs = [];
             let currentClusterText = '';
-            let clusterStartPosition = new three.Vector3();
-            let cursor = new three.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++) {
@@ -5173,7 +5449,7 @@
                 }
                 const absoluteGlyphPosition = cursor
                     .clone()
-                    .add(new three.Vector3(glyph.dx, glyph.dy, 0));
+                    .add(new Vec3(glyph.dx, glyph.dy, 0));
                 if (!isWhitespace) {
                     if (currentClusterGlyphs.length === 0) {
                         clusterStartPosition.copy(absoluteGlyphPosition);
@@ -5306,7 +5582,7 @@
             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;
@@ -6122,9 +6398,9 @@
                     max: { x: 0, y: 0, z: 0 }
                 };
             }
-            const box = new three.Box3();
+            const box = new Box3();
             for (const glyph of glyphs) {
-                const glyphBox = new three.Box3(new three.Vector3(glyph.bounds.min.x, glyph.bounds.min.y, glyph.bounds.min.z), new three.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 {
@@ -6155,7 +6431,7 @@
             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();
@@ -6289,9 +6565,10 @@
                 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;
             }
@@ -6403,8 +6680,8 @@
                 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
@@ -6494,16 +6771,15 @@
                     });
                 }
             }
-            geometry.setAttribute('color', new three.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
@@ -6512,7 +6788,13 @@
             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;
@@ -6532,15 +6814,22 @@
                 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: {
@@ -6558,7 +6847,8 @@
                     const queryInstance = new TextRangeQuery(originalText, glyphInfoArray);
                     return queryInstance.execute(options);
                 },
-                coloredRanges
+                coloredRanges,
+                glyphAttributes: undefined
             };
         }
         getFontMetrics() {
@@ -6603,8 +6893,7 @@
                 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);
@@ -6623,9 +6912,11 @@
                     }
                 }
             });
-            geometry.setAttribute('glyphCenter', new three.Float32BufferAttribute(glyphCenters, 3));
-            geometry.setAttribute('glyphIndex', new three.Float32BufferAttribute(glyphIndices, 1));
-            geometry.setAttribute('glyphLineIndex', new three.Float32BufferAttribute(glyphLineIndices, 1));
+            return {
+                glyphCenter: glyphCenters,
+                glyphIndex: glyphIndices,
+                glyphLineIndex: glyphLineIndices
+            };
         }
         destroy() {
             if (!this.loadedFont) {