three-text 0.2.19 → 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) => {

package/dist/three/index.d.ts

@@ -10,21 +10,10 @@ interface HyphenationTrieNode {
     };
 }
 
-interface CacheStats {
-    hits: number;
-    misses: number;
-    evictions: number;
-    size: number;
-    memoryUsage: number;
-}
-
 interface ThreeTextGeometryInfo extends Omit<TextGeometryInfo, 'vertices' | 'normals' | 'indices' | 'colors' | 'glyphAttributes'> {
     geometry: BufferGeometry;
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): (CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<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) => {

package/dist/three/react.d.ts

@@ -10,11 +10,7 @@ interface HyphenationTrieNode {
 }
 
 interface CacheStats {
-    hits: number;
-    misses: number;
-    evictions: number;
     size: number;
-    memoryUsage: number;
 }
 
 interface BoundingBox {
@@ -182,6 +178,8 @@ interface TextGeometryInfo {
         glyphCenter: Float32Array;
         glyphIndex: Float32Array;
         glyphLineIndex: Float32Array;
+        glyphProgress: Float32Array;
+        glyphBaselineY: Float32Array;
     };
     glyphs: GlyphGeometryInfo[];
     planeBounds: BoundingBox;
@@ -200,10 +198,7 @@ interface TextGeometryInfo {
 }
 interface TextHandle extends TextGeometryInfo {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): (CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
@@ -247,7 +242,7 @@ interface TextOptions {
     depth?: number;
     lineHeight?: number;
     letterSpacing?: number;
-    separateGlyphsWithAttributes?: boolean;
+    perGlyphAttributes?: boolean;
     fontVariations?: {
         [key: string]: number;
     };
@@ -346,10 +341,7 @@ declare class Text$1 {
     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;

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

@@ -46,10 +46,7 @@ export declare class Text {
     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,5 +1,5 @@
 import type { HyphenationTrieNode } from '../hyphenation';
-import type { CacheStats } from '../utils/LRUCache';
+import type { CacheStats } from '../utils/Cache';
 import type { Vec2, Vec3, BoundingBox } from './vectors';
 export type { HyphenationTrieNode };
 export interface Path {
@@ -241,6 +241,8 @@ export interface TextGeometryInfo {
         glyphCenter: Float32Array;
         glyphIndex: Float32Array;
         glyphLineIndex: Float32Array;
+        glyphProgress: Float32Array;
+        glyphBaselineY: Float32Array;
     };
     glyphs: GlyphGeometryInfo[];
     planeBounds: BoundingBox;
@@ -259,10 +261,7 @@ export interface TextGeometryInfo {
 }
 export interface TextHandle extends TextGeometryInfo {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): (CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
@@ -306,7 +305,7 @@ export interface TextOptions {
     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

@@ -2,14 +2,10 @@ import { BufferGeometry } from 'three';
 import { Text as TextCore } from '../core/Text';
 import type { TextOptions, TextGeometryInfo as CoreTextGeometryInfo, LoadedFont } from '../core/types';
 import type { HyphenationTrieNode } from '../hyphenation';
-import type { CacheStats } from '../utils/LRUCache';
 export interface ThreeTextGeometryInfo extends Omit<CoreTextGeometryInfo, 'vertices' | 'normals' | 'indices' | 'colors' | 'glyphAttributes'> {
     geometry: BufferGeometry;
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): (CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }) | null;
+    getCacheSize(): number;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;

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;

package/dist/webgpu/index.js

@@ -1,6 +1,6 @@
 // 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
@@ -81,6 +81,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,
@@ -91,6 +160,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();
         }
     };
 }