three-text 0.2.18 → 0.3.0

package/dist/three/index.cjs

@@ -19,6 +19,8 @@ function convertToThree(result) {
         geometry.setAttribute('glyphCenter', new three.Float32BufferAttribute(result.glyphAttributes.glyphCenter, 3));
         geometry.setAttribute('glyphIndex', new three.Float32BufferAttribute(result.glyphAttributes.glyphIndex, 1));
         geometry.setAttribute('glyphLineIndex', new three.Float32BufferAttribute(result.glyphAttributes.glyphLineIndex, 1));
+        geometry.setAttribute('glyphProgress', new three.Float32BufferAttribute(result.glyphAttributes.glyphProgress, 1));
+        geometry.setAttribute('glyphBaselineY', new three.Float32BufferAttribute(result.glyphAttributes.glyphBaselineY, 1));
     }
     geometry.computeBoundingBox();
     // Return Three.js specific interface with utility methods
@@ -31,7 +33,7 @@ function convertToThree(result) {
         coloredRanges: result.coloredRanges,
         // Pass through utility methods from core
         getLoadedFont: result.getLoadedFont,
-        getCacheStatistics: result.getCacheStatistics,
+        getCacheSize: result.getCacheSize,
         clearCache: result.clearCache,
         measureTextWidth: result.measureTextWidth,
         update: async (newOptions) => {
@@ -47,6 +49,7 @@ class Text {
     static { this.init = Text$1.Text.init; }
     static { this.registerPattern = Text$1.Text.registerPattern; }
     static { this.preloadPatterns = Text$1.Text.preloadPatterns; }
+    static { this.setMaxFontCacheMemoryMB = Text$1.Text.setMaxFontCacheMemoryMB; }
     // Main API - wraps core result in BufferGeometry
     static async create(options) {
         const coreResult = await Text$1.Text.create(options);

package/dist/three/index.d.ts

@@ -13,7 +13,7 @@ interface HyphenationTrieNode {
 interface ThreeTextGeometryInfo extends Omit<TextGeometryInfo, 'vertices' | 'normals' | 'indices' | 'colors' | 'glyphAttributes'> {
     geometry: BufferGeometry;
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): any;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
@@ -24,6 +24,7 @@ declare class Text {
     static init: typeof Text$1.init;
     static registerPattern: typeof Text$1.registerPattern;
     static preloadPatterns: typeof Text$1.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
     static create(options: TextOptions): Promise<ThreeTextGeometryInfo>;
 }
 

package/dist/three/index.js

@@ -17,6 +17,8 @@ function convertToThree(result) {
         geometry.setAttribute('glyphCenter', new Float32BufferAttribute(result.glyphAttributes.glyphCenter, 3));
         geometry.setAttribute('glyphIndex', new Float32BufferAttribute(result.glyphAttributes.glyphIndex, 1));
         geometry.setAttribute('glyphLineIndex', new Float32BufferAttribute(result.glyphAttributes.glyphLineIndex, 1));
+        geometry.setAttribute('glyphProgress', new Float32BufferAttribute(result.glyphAttributes.glyphProgress, 1));
+        geometry.setAttribute('glyphBaselineY', new Float32BufferAttribute(result.glyphAttributes.glyphBaselineY, 1));
     }
     geometry.computeBoundingBox();
     // Return Three.js specific interface with utility methods
@@ -29,7 +31,7 @@ function convertToThree(result) {
         coloredRanges: result.coloredRanges,
         // Pass through utility methods from core
         getLoadedFont: result.getLoadedFont,
-        getCacheStatistics: result.getCacheStatistics,
+        getCacheSize: result.getCacheSize,
         clearCache: result.clearCache,
         measureTextWidth: result.measureTextWidth,
         update: async (newOptions) => {
@@ -45,6 +47,7 @@ class Text {
     static { this.init = Text$1.init; }
     static { this.registerPattern = Text$1.registerPattern; }
     static { this.preloadPatterns = Text$1.preloadPatterns; }
+    static { this.setMaxFontCacheMemoryMB = Text$1.setMaxFontCacheMemoryMB; }
     // Main API - wraps core result in BufferGeometry
     static async create(options) {
         const coreResult = await Text$1.create(options);

package/dist/three/react.cjs

@@ -3,7 +3,7 @@
 var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
 var THREE = require('three');
-var index = require('./index');
+var index = require('./index.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -142,6 +142,7 @@ const Text = Object.assign(Text$1, {
     init: index.Text.init,
     registerPattern: index.Text.registerPattern,
     preloadPatterns: index.Text.preloadPatterns,
+    setMaxFontCacheMemoryMB: index.Text.setMaxFontCacheMemoryMB,
     create: index.Text.create
 });
 

package/dist/three/react.d.ts

@@ -9,6 +9,10 @@ interface HyphenationTrieNode {
     };
 }
 
+interface CacheStats {
+    size: number;
+}
+
 interface BoundingBox {
     min: {
         x: number;
@@ -174,6 +178,8 @@ interface TextGeometryInfo {
         glyphCenter: Float32Array;
         glyphIndex: Float32Array;
         glyphLineIndex: Float32Array;
+        glyphProgress: Float32Array;
+        glyphBaselineY: Float32Array;
     };
     glyphs: GlyphGeometryInfo[];
     planeBounds: BoundingBox;
@@ -183,13 +189,16 @@ interface TextGeometryInfo {
         pointsRemovedByVisvalingam: number;
         pointsRemovedByColinear: number;
         originalPointCount: number;
-    };
+    } & Partial<CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }>;
     query(options: TextQueryOptions): TextRange[];
     coloredRanges?: ColoredRange[];
 }
 interface TextHandle extends TextGeometryInfo {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): any;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
@@ -228,12 +237,12 @@ interface ColoredRange {
 }
 interface TextOptions {
     text: string;
-    font?: string | ArrayBuffer;
+    font: string | ArrayBuffer;
     size?: number;
     depth?: number;
     lineHeight?: number;
     letterSpacing?: number;
-    separateGlyphsWithAttributes?: boolean;
+    perGlyphAttributes?: boolean;
     fontVariations?: {
         [key: string]: number;
     };
@@ -329,28 +338,16 @@ declare class Text$1 {
     getFontMetrics(): FontMetrics;
     static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
     static registerPattern(language: string, pattern: HyphenationTrieNode): void;
-    static clearFontCache(): void;
     static setMaxFontCacheMemoryMB(limitMB: number): void;
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    getCacheStatistics(): (CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     private createGlyphAttributes;
     private resetHelpers;
     destroy(): void;
 }
 
-interface CacheStats {
-    hits: number;
-    misses: number;
-    evictions: number;
-    size: number;
-    memoryUsage: number;
-}
-
 interface ThreeTextProps extends Omit<TextOptions$1, 'text'> {
     children: string;
     font: string | ArrayBuffer;
@@ -369,6 +366,7 @@ declare const Text: react.ForwardRefExoticComponent<ThreeTextProps & react.RefAt
     init: typeof Text$1.init;
     registerPattern: typeof Text$1.registerPattern;
     preloadPatterns: typeof Text$1.preloadPatterns;
+    setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
     create: typeof Text$2.create;
 };
 

package/dist/three/react.js

@@ -1,7 +1,7 @@
 import { jsx } from 'react/jsx-runtime';
 import { forwardRef, useState, useRef, useMemo, useEffect } from 'react';
 import * as THREE from 'three';
-import { Text as Text$2 } from './index';
+import { Text as Text$2 } from './index.js';
 
 function deepEqual(a, b) {
     if (a === b)
@@ -121,6 +121,7 @@ const Text = Object.assign(Text$1, {
     init: Text$2.init,
     registerPattern: Text$2.registerPattern,
     preloadPatterns: Text$2.preloadPatterns,
+    setMaxFontCacheMemoryMB: Text$2.setMaxFontCacheMemoryMB,
     create: Text$2.create
 });
 

package/dist/types/core/Text.d.ts

@@ -43,14 +43,10 @@ export declare class Text {
     getFontMetrics(): FontMetrics;
     static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
     static registerPattern(language: string, pattern: HyphenationTrieNode): void;
-    static clearFontCache(): void;
     static setMaxFontCacheMemoryMB(limitMB: number): void;
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    getCacheStatistics(): (import("..").CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     private createGlyphAttributes;
     private resetHelpers;

package/dist/types/core/cache/GlyphGeometryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { GlyphGeometryInfo, LoadedFont, GlyphCluster, GlyphData } from '../types';
 import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
-import { LRUCache } from '../../utils/LRUCache';
+import { Cache } from '../../utils/Cache';
 export interface InstancedTextGeometry {
     vertices: Float32Array;
     normals: Float32Array;
@@ -35,14 +35,14 @@ export declare class GlyphGeometryBuilder {
     private contourCache;
     private clusteringCache;
     private emptyGlyphs;
-    constructor(cache: LRUCache<string, GlyphData>, loadedFont: LoadedFont);
+    constructor(cache: Cache<string, GlyphData>, loadedFont: LoadedFont);
     getOptimizationStats(): import("../geometry/PathOptimizer").OptimizationStats;
     setCurveFidelityConfig(config?: CurveFidelityConfig): void;
     setGeometryOptimization(options?: GeometryOptimizationOptions): void;
     setFontId(fontId: string): void;
     private updateCacheKeyPrefix;
     private getGeometryConfigSignature;
-    buildInstancedGeometry(clustersByLine: GlyphCluster[][], depth: number, removeOverlaps: boolean, isCFF: boolean, separateGlyphs?: boolean, coloredTextIndices?: Set<number>): InstancedTextGeometry;
+    buildInstancedGeometry(clustersByLine: GlyphCluster[][], depth: number, removeOverlaps: boolean, isCFF: boolean, scale: number, separateGlyphs?: boolean, coloredTextIndices?: Set<number>): InstancedTextGeometry;
     private getClusterKey;
     private createGlyphInfo;
     private getContoursForGlyph;
@@ -50,9 +50,6 @@ export declare class GlyphGeometryBuilder {
     private extrudeAndPackage;
     private tessellateGlyph;
     private updatePlaneBounds;
-    getCacheStats(): import("../../utils/LRUCache").CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    };
+    getCacheStats(): import("../../utils/Cache").CacheStats;
     clearCache(): void;
 }

package/dist/types/core/cache/sharedCaches.d.ts

@@ -1,12 +1,11 @@
-import { LRUCache } from '../../utils/LRUCache';
+import { Cache } from '../../utils/Cache';
 import type { GlyphData, GlyphContours } from '../types';
 export declare function getGlyphCacheKey(fontId: string, glyphId: number, depth: number, removeOverlaps: boolean): string;
-export declare function calculateGlyphMemoryUsage(glyph: GlyphData): number;
-export declare const globalGlyphCache: LRUCache<string, GlyphData>;
-export declare function createGlyphCache(maxCacheSizeMB?: number): LRUCache<string, GlyphData>;
-export declare const globalContourCache: LRUCache<string, GlyphContours>;
-export declare const globalWordCache: LRUCache<string, GlyphData>;
-export declare const globalClusteringCache: LRUCache<string, {
+export declare const globalGlyphCache: Cache<string, GlyphData>;
+export declare function createGlyphCache(): Cache<string, GlyphData>;
+export declare const globalContourCache: Cache<string, GlyphContours>;
+export declare const globalWordCache: Cache<string, GlyphData>;
+export declare const globalClusteringCache: Cache<string, {
     glyphIds: number[];
     groups: number[][];
 }>;

package/dist/types/core/geometry/Extruder.d.ts

@@ -6,6 +6,5 @@ export interface ExtrusionResult {
 }
 export declare class Extruder {
     constructor();
-    private packEdge;
     extrude(geometry: ProcessedGeometry, depth: number | undefined, unitsPerEm: number): ExtrusionResult;
 }

package/dist/types/core/shaping/TextShaper.d.ts

@@ -31,8 +31,5 @@ export declare class TextShaper {
     private calculateSpaceAdjustment;
     private calculateCJKAdjustment;
     clearCache(): void;
-    getCacheStats(): import("../..").CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    };
+    getCacheStats(): import("../..").CacheStats;
 }

package/dist/types/core/types.d.ts

@@ -1,4 +1,5 @@
 import type { HyphenationTrieNode } from '../hyphenation';
+import type { CacheStats } from '../utils/Cache';
 import type { Vec2, Vec3, BoundingBox } from './vectors';
 export type { HyphenationTrieNode };
 export interface Path {
@@ -240,6 +241,8 @@ export interface TextGeometryInfo {
         glyphCenter: Float32Array;
         glyphIndex: Float32Array;
         glyphLineIndex: Float32Array;
+        glyphProgress: Float32Array;
+        glyphBaselineY: Float32Array;
     };
     glyphs: GlyphGeometryInfo[];
     planeBounds: BoundingBox;
@@ -249,13 +252,16 @@ export interface TextGeometryInfo {
         pointsRemovedByVisvalingam: number;
         pointsRemovedByColinear: number;
         originalPointCount: number;
-    };
+    } & Partial<CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }>;
     query(options: TextQueryOptions): TextRange[];
     coloredRanges?: ColoredRange[];
 }
 export interface TextHandle extends TextGeometryInfo {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): any;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
@@ -294,12 +300,12 @@ export interface ColoredRange {
 }
 export interface TextOptions {
     text: string;
-    font?: string | ArrayBuffer;
+    font: string | ArrayBuffer;
     size?: number;
     depth?: number;
     lineHeight?: number;
     letterSpacing?: number;
-    separateGlyphsWithAttributes?: boolean;
+    perGlyphAttributes?: boolean;
     fontVariations?: {
         [key: string]: number;
     };

package/dist/types/index.d.ts

@@ -2,6 +2,6 @@ export { Text } from './core/Text';
 export { DEFAULT_CURVE_FIDELITY } from './core/geometry/Polygonizer';
 export { FontMetadataExtractor } from './core/font/FontMetadata';
 export { globalGlyphCache, createGlyphCache } from './core/cache/sharedCaches';
-export type { CacheStats } from './utils/LRUCache';
+export type { CacheStats } from './utils/Cache';
 export type { TextAlign, TextDirection, LineInfo, LoadedFont, HarfBuzzModule, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzFace, HarfBuzzFont, HarfBuzzBuffer, HarfBuzzInstance, VariationAxis, ExtractedMetrics, VerticalMetrics, FontMetrics, ProcessedGeometry, Triangles, GlyphData, GlyphGeometryInfo, TextGeometryInfo, TextHandle, TextOptions, ColorOptions, ColorByRange, ColoredRange, PathInfo, HyphenationPatternsMap, CurveFidelityConfig, LayoutOptions, GeometryOptimizationOptions, TextRange, TextQueryOptions } from './core/types';
 export type { HyphenationTrieNode } from './hyphenation';

package/dist/types/three/index.d.ts

@@ -5,7 +5,7 @@ import type { HyphenationTrieNode } from '../hyphenation';
 export interface ThreeTextGeometryInfo extends Omit<CoreTextGeometryInfo, 'vertices' | 'normals' | 'indices' | 'colors' | 'glyphAttributes'> {
     geometry: BufferGeometry;
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): any;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
@@ -16,6 +16,7 @@ export declare class Text {
     static init: typeof TextCore.init;
     static registerPattern: typeof TextCore.registerPattern;
     static preloadPatterns: typeof TextCore.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof TextCore.setMaxFontCacheMemoryMB;
     static create(options: TextOptions): Promise<ThreeTextGeometryInfo>;
 }
 export type { TextOptions, ThreeTextGeometryInfo as TextGeometryInfo, LoadedFont };

package/dist/types/three/react.d.ts

@@ -6,5 +6,6 @@ export declare const Text: import("react").ForwardRefExoticComponent<import("./T
     init: typeof import("..").Text.init;
     registerPattern: typeof import("..").Text.registerPattern;
     preloadPatterns: typeof import("..").Text.preloadPatterns;
+    setMaxFontCacheMemoryMB: typeof import("..").Text.setMaxFontCacheMemoryMB;
     create: typeof ThreeTextCore.create;
 };

package/dist/types/utils/Cache.d.ts

@@ -0,0 +1,14 @@
+export interface CacheStats {
+    size: number;
+}
+export declare class Cache<K, V> {
+    private cache;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): K[];
+    getStats(): CacheStats;
+}

package/dist/types/webgl/index.d.ts

@@ -8,6 +8,8 @@ export interface WebGLBufferSet {
         glyphCenter?: WebGLBuffer;
         glyphIndex?: WebGLBuffer;
         glyphLineIndex?: WebGLBuffer;
+        glyphProgress?: WebGLBuffer;
+        glyphBaselineY?: WebGLBuffer;
     };
     attributes: {
         position: {
@@ -40,6 +42,16 @@ export interface WebGLBufferSet {
             type: GLenum;
             normalized: boolean;
         };
+        glyphProgress?: {
+            size: number;
+            type: GLenum;
+            normalized: boolean;
+        };
+        glyphBaselineY?: {
+            size: number;
+            type: GLenum;
+            normalized: boolean;
+        };
     };
     drawCount: number;
     mode: GLenum;

package/dist/types/webgpu/index.d.ts

@@ -4,10 +4,20 @@ export interface WebGPUBufferSet {
         vertex: GPUBuffer;
         color?: GPUBuffer;
         indices: GPUBuffer;
+        glyphCenter?: GPUBuffer;
+        glyphIndex?: GPUBuffer;
+        glyphLineIndex?: GPUBuffer;
+        glyphProgress?: GPUBuffer;
+        glyphBaselineY?: GPUBuffer;
     };
     layout: {
         vertex: GPUVertexBufferLayout;
         color?: GPUVertexBufferLayout;
+        glyphCenter?: GPUVertexBufferLayout;
+        glyphIndex?: GPUVertexBufferLayout;
+        glyphLineIndex?: GPUVertexBufferLayout;
+        glyphProgress?: GPUVertexBufferLayout;
+        glyphBaselineY?: GPUVertexBufferLayout;
     };
     indexCount: number;
     indexFormat: GPUIndexFormat;

package/dist/webgl/index.cjs

@@ -63,6 +63,20 @@ function createWebGLBuffers(gl, textGeometry) {
         gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphLineIndex, gl.STATIC_DRAW);
         buffers.glyphLineIndex = glyphLineIndexBuffer;
         attributes.glyphLineIndex = { size: 1, type: gl.FLOAT, normalized: false };
+        const glyphProgressBuffer = gl.createBuffer();
+        if (!glyphProgressBuffer)
+            throw new Error('Failed to create glyphProgress buffer');
+        gl.bindBuffer(gl.ARRAY_BUFFER, glyphProgressBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphProgress, gl.STATIC_DRAW);
+        buffers.glyphProgress = glyphProgressBuffer;
+        attributes.glyphProgress = { size: 1, type: gl.FLOAT, normalized: false };
+        const glyphBaselineYBuffer = gl.createBuffer();
+        if (!glyphBaselineYBuffer)
+            throw new Error('Failed to create glyphBaselineY buffer');
+        gl.bindBuffer(gl.ARRAY_BUFFER, glyphBaselineYBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphBaselineY, gl.STATIC_DRAW);
+        buffers.glyphBaselineY = glyphBaselineYBuffer;
+        attributes.glyphBaselineY = { size: 1, type: gl.FLOAT, normalized: false };
     }
     return {
         buffers,
@@ -81,6 +95,10 @@ function createWebGLBuffers(gl, textGeometry) {
                 gl.deleteBuffer(buffers.glyphIndex);
             if (buffers.glyphLineIndex)
                 gl.deleteBuffer(buffers.glyphLineIndex);
+            if (buffers.glyphProgress)
+                gl.deleteBuffer(buffers.glyphProgress);
+            if (buffers.glyphBaselineY)
+                gl.deleteBuffer(buffers.glyphBaselineY);
         }
     };
 }

package/dist/webgl/index.d.ts

@@ -9,6 +9,8 @@ interface WebGLBufferSet {
         glyphCenter?: WebGLBuffer;
         glyphIndex?: WebGLBuffer;
         glyphLineIndex?: WebGLBuffer;
+        glyphProgress?: WebGLBuffer;
+        glyphBaselineY?: WebGLBuffer;
     };
     attributes: {
         position: {
@@ -41,6 +43,16 @@ interface WebGLBufferSet {
             type: GLenum;
             normalized: boolean;
         };
+        glyphProgress?: {
+            size: number;
+            type: GLenum;
+            normalized: boolean;
+        };
+        glyphBaselineY?: {
+            size: number;
+            type: GLenum;
+            normalized: boolean;
+        };
     };
     drawCount: number;
     mode: GLenum;

package/dist/webgl/index.js

@@ -61,6 +61,20 @@ function createWebGLBuffers(gl, textGeometry) {
         gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphLineIndex, gl.STATIC_DRAW);
         buffers.glyphLineIndex = glyphLineIndexBuffer;
         attributes.glyphLineIndex = { size: 1, type: gl.FLOAT, normalized: false };
+        const glyphProgressBuffer = gl.createBuffer();
+        if (!glyphProgressBuffer)
+            throw new Error('Failed to create glyphProgress buffer');
+        gl.bindBuffer(gl.ARRAY_BUFFER, glyphProgressBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphProgress, gl.STATIC_DRAW);
+        buffers.glyphProgress = glyphProgressBuffer;
+        attributes.glyphProgress = { size: 1, type: gl.FLOAT, normalized: false };
+        const glyphBaselineYBuffer = gl.createBuffer();
+        if (!glyphBaselineYBuffer)
+            throw new Error('Failed to create glyphBaselineY buffer');
+        gl.bindBuffer(gl.ARRAY_BUFFER, glyphBaselineYBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, glyphAttributes.glyphBaselineY, gl.STATIC_DRAW);
+        buffers.glyphBaselineY = glyphBaselineYBuffer;
+        attributes.glyphBaselineY = { size: 1, type: gl.FLOAT, normalized: false };
     }
     return {
         buffers,
@@ -79,6 +93,10 @@ function createWebGLBuffers(gl, textGeometry) {
                 gl.deleteBuffer(buffers.glyphIndex);
             if (buffers.glyphLineIndex)
                 gl.deleteBuffer(buffers.glyphLineIndex);
+            if (buffers.glyphProgress)
+                gl.deleteBuffer(buffers.glyphProgress);
+            if (buffers.glyphBaselineY)
+                gl.deleteBuffer(buffers.glyphBaselineY);
         }
     };
 }

package/dist/webgpu/index.cjs

@@ -2,7 +2,7 @@
 
 // WebGPU adapter - lightweight utility to create GPU buffers from core geometry
 function createWebGPUBuffers(device, textGeometry) {
-    const { vertices, normals, indices, colors } = textGeometry;
+    const { vertices, normals, indices, colors, glyphAttributes } = textGeometry;
     const indexCount = indices.length;
     const indexFormat = indices instanceof Uint16Array ? 'uint16' : 'uint32';
     // Interleave position and normal data for better cache coherency
@@ -83,6 +83,75 @@ function createWebGPUBuffers(device, textGeometry) {
         buffers.color = colorBuffer;
         layout.color = colorLayout;
     }
+    // Optional glyph attribute buffers
+    let glyphCenterBuffer;
+    let glyphIndexBuffer;
+    let glyphLineIndexBuffer;
+    let glyphProgressBuffer;
+    let glyphBaselineYBuffer;
+    if (glyphAttributes) {
+        let nextShaderLocation = colors ? 3 : 2;
+        glyphCenterBuffer = device.createBuffer({
+            size: glyphAttributes.glyphCenter.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(glyphCenterBuffer.getMappedRange()).set(glyphAttributes.glyphCenter);
+        glyphCenterBuffer.unmap();
+        buffers.glyphCenter = glyphCenterBuffer;
+        layout.glyphCenter = {
+            arrayStride: 12,
+            attributes: [{ shaderLocation: nextShaderLocation++, offset: 0, format: 'float32x3' }]
+        };
+        glyphIndexBuffer = device.createBuffer({
+            size: glyphAttributes.glyphIndex.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(glyphIndexBuffer.getMappedRange()).set(glyphAttributes.glyphIndex);
+        glyphIndexBuffer.unmap();
+        buffers.glyphIndex = glyphIndexBuffer;
+        layout.glyphIndex = {
+            arrayStride: 4,
+            attributes: [{ shaderLocation: nextShaderLocation++, offset: 0, format: 'float32' }]
+        };
+        glyphLineIndexBuffer = device.createBuffer({
+            size: glyphAttributes.glyphLineIndex.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(glyphLineIndexBuffer.getMappedRange()).set(glyphAttributes.glyphLineIndex);
+        glyphLineIndexBuffer.unmap();
+        buffers.glyphLineIndex = glyphLineIndexBuffer;
+        layout.glyphLineIndex = {
+            arrayStride: 4,
+            attributes: [{ shaderLocation: nextShaderLocation++, offset: 0, format: 'float32' }]
+        };
+        glyphProgressBuffer = device.createBuffer({
+            size: glyphAttributes.glyphProgress.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(glyphProgressBuffer.getMappedRange()).set(glyphAttributes.glyphProgress);
+        glyphProgressBuffer.unmap();
+        buffers.glyphProgress = glyphProgressBuffer;
+        layout.glyphProgress = {
+            arrayStride: 4,
+            attributes: [{ shaderLocation: nextShaderLocation++, offset: 0, format: 'float32' }]
+        };
+        glyphBaselineYBuffer = device.createBuffer({
+            size: glyphAttributes.glyphBaselineY.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(glyphBaselineYBuffer.getMappedRange()).set(glyphAttributes.glyphBaselineY);
+        glyphBaselineYBuffer.unmap();
+        buffers.glyphBaselineY = glyphBaselineYBuffer;
+        layout.glyphBaselineY = {
+            arrayStride: 4,
+            attributes: [{ shaderLocation: nextShaderLocation++, offset: 0, format: 'float32' }]
+        };
+    }
     return {
         buffers,
         layout,
@@ -93,6 +162,16 @@ function createWebGPUBuffers(device, textGeometry) {
             indexBuffer.destroy();
             if (colorBuffer)
                 colorBuffer.destroy();
+            if (glyphCenterBuffer)
+                glyphCenterBuffer.destroy();
+            if (glyphIndexBuffer)
+                glyphIndexBuffer.destroy();
+            if (glyphLineIndexBuffer)
+                glyphLineIndexBuffer.destroy();
+            if (glyphProgressBuffer)
+                glyphProgressBuffer.destroy();
+            if (glyphBaselineYBuffer)
+                glyphBaselineYBuffer.destroy();
         }
     };
 }

package/dist/webgpu/index.d.ts

@@ -5,10 +5,20 @@ interface WebGPUBufferSet {
         vertex: GPUBuffer;
         color?: GPUBuffer;
         indices: GPUBuffer;
+        glyphCenter?: GPUBuffer;
+        glyphIndex?: GPUBuffer;
+        glyphLineIndex?: GPUBuffer;
+        glyphProgress?: GPUBuffer;
+        glyphBaselineY?: GPUBuffer;
     };
     layout: {
         vertex: GPUVertexBufferLayout;
         color?: GPUVertexBufferLayout;
+        glyphCenter?: GPUVertexBufferLayout;
+        glyphIndex?: GPUVertexBufferLayout;
+        glyphLineIndex?: GPUVertexBufferLayout;
+        glyphProgress?: GPUVertexBufferLayout;
+        glyphBaselineY?: GPUVertexBufferLayout;
     };
     indexCount: number;
     indexFormat: GPUIndexFormat;