meshwriter-cudu 3.0.0 → 3.0.3

package/dist/src/fogPlugin.d.ts

@@ -1,6 +1,6 @@
 /**
- * Plugin that applies scene fog to text materials by modifying
- * the final fragment color before output.
+ * Plugin that applies scene fog to text materials uniformly.
+ * Handles fog for both diffuse and emissive components in one pass.
  */
 export class TextFogPlugin extends MaterialPluginBase {
     /**
@@ -14,19 +14,45 @@ export class TextFogPlugin extends MaterialPluginBase {
      * @param {import('@babylonjs/core/Meshes/mesh').Mesh} mesh
      */
     prepareDefines(defines: object, scene: import("@babylonjs/core/scene").Scene, mesh: import("@babylonjs/core/Meshes/mesh").Mesh): void;
+    /**
+     * Define our own fog uniforms since material.fogEnabled = false
+     * means Babylon's built-in fog uniforms won't be available
+     */
     getUniforms(): {
-        ubo: any[];
+        ubo: {
+            name: string;
+            size: number;
+            type: string;
+        }[];
+        vertex: string;
+        fragment: string;
     };
+    /**
+     * Bind fog values from the scene to our custom uniforms
+     * @param {import('@babylonjs/core/Materials/uniformBuffer').UniformBuffer} uniformBuffer
+     * @param {import('@babylonjs/core/scene').Scene} scene
+     * @param {import('@babylonjs/core/Engines/engine').Engine} engine
+     * @param {import('@babylonjs/core/Meshes/subMesh').SubMesh} subMesh
+     */
+    bindForSubMesh(uniformBuffer: import("@babylonjs/core/Materials/uniformBuffer").UniformBuffer, scene: import("@babylonjs/core/scene").Scene, engine: import("@babylonjs/core/Engines/engine").Engine, subMesh: import("@babylonjs/core/Meshes/subMesh").SubMesh): void;
     /**
      * Clean up the plugin
      */
     dispose(): void;
     /**
-     * Inject shader code to apply fog to emissive color
+     * Inject shader code to calculate fog distance and apply fog blending
      * @param {string} shaderType - 'vertex' or 'fragment'
      */
     getCustomCode(shaderType: string): {
+        CUSTOM_VERTEX_DEFINITIONS: string;
+        CUSTOM_VERTEX_MAIN_END: string;
+        CUSTOM_FRAGMENT_DEFINITIONS?: undefined;
+        CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR?: undefined;
+    } | {
+        CUSTOM_FRAGMENT_DEFINITIONS: string;
         CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: string;
+        CUSTOM_VERTEX_DEFINITIONS?: undefined;
+        CUSTOM_VERTEX_MAIN_END?: undefined;
     };
 }
 import { MaterialPluginBase } from './babylonImports.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meshwriter-cudu",
-    "version": "3.0.0",
+    "version": "3.0.3",
     "description": "Modern 3D text rendering for Babylon.js with variable font weights and accessibility features",
     "type": "module",
     "main": "./dist/meshwriter.cjs.js",
@@ -40,7 +40,10 @@
         "typescript",
         "esm"
     ],
-    "authors": ["Brian T Button","Cullen Dudas"],
+    "authors": [
+        "Brian T Button",
+        "Cullen Dudas"
+    ],
     "license": "MIT",
     "peerDependencies": {
         "@babylonjs/core": ">=6.0.0",
@@ -56,7 +59,7 @@
     },
     "devDependencies": {
         "@babylonjs/core": "^8.0.0",
-        "@rollup/plugin-commonjs": "^28.0.0",
+        "@rollup/plugin-commonjs": "^29.0.0",
         "@rollup/plugin-node-resolve": "^16.0.0",
         "@rollup/plugin-terser": "^0.4.0",
         "earcut": "^3.0.2",

package/src/fogPlugin.js

@@ -1,16 +1,19 @@
 /**
- * TextFogPlugin - MaterialPluginBase that applies fog to emissive color
+ * TextFogPlugin - MaterialPluginBase that applies fog to text materials
  *
- * Babylon's standard fog only affects diffuse/ambient channels.
- * This plugin recalculates fog blending for the final color output,
- * ensuring emissive text fades properly with distance fog.
+ * Since we disable Babylon's built-in fog (material.fogEnabled = false) to avoid
+ * double-fogging of diffuse colors, this plugin handles ALL fog application.
+ * It supplies its own uniforms and varyings to calculate fog distance and blend.
+ *
+ * This ensures text (with emissive colors) fades into fog at the same rate as
+ * terrain (which uses only diffuse colors with standard fog).
  */
 
 import { MaterialPluginBase } from './babylonImports.js';
 
 /**
- * Plugin that applies scene fog to text materials by modifying
- * the final fragment color before output.
+ * Plugin that applies scene fog to text materials uniformly.
+ * Handles fog for both diffuse and emissive components in one pass.
  */
 export class TextFogPlugin extends MaterialPluginBase {
     /**
@@ -31,6 +34,7 @@ export class TextFogPlugin extends MaterialPluginBase {
      */
     prepareDefines(defines, scene, mesh) {
         // Enable when scene has any fog mode set (1=LINEAR, 2=EXP, 3=EXP2)
+        // This is independent of material.fogEnabled since we handle fog ourselves
         defines['MESHWRITER_TEXT_FOG'] = scene.fogMode !== 0;
     }
 
@@ -38,10 +42,45 @@ export class TextFogPlugin extends MaterialPluginBase {
         return 'TextFogPlugin';
     }
 
+    /**
+     * Define our own fog uniforms since material.fogEnabled = false
+     * means Babylon's built-in fog uniforms won't be available
+     */
     getUniforms() {
-        // We use Babylon's built-in fog uniforms (vFogInfos, vFogColor)
-        // which are already available in the standard material
-        return { ubo: [] };
+        return {
+            ubo: [
+                { name: 'textFogInfos', size: 4, type: 'vec4' },
+                { name: 'textFogColor', size: 3, type: 'vec3' }
+            ],
+            vertex: '',
+            fragment: ''
+        };
+    }
+
+    /**
+     * Bind fog values from the scene to our custom uniforms
+     * @param {import('@babylonjs/core/Materials/uniformBuffer').UniformBuffer} uniformBuffer
+     * @param {import('@babylonjs/core/scene').Scene} scene
+     * @param {import('@babylonjs/core/Engines/engine').Engine} engine
+     * @param {import('@babylonjs/core/Meshes/subMesh').SubMesh} subMesh
+     */
+    bindForSubMesh(uniformBuffer, scene, engine, subMesh) {
+        if (scene.fogMode === 0) return;
+
+        // textFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
+        uniformBuffer.updateFloat4(
+            'textFogInfos',
+            scene.fogMode,
+            scene.fogStart,
+            scene.fogEnd,
+            scene.fogDensity
+        );
+
+        // textFogColor: RGB color of the fog
+        uniformBuffer.updateColor3(
+            'textFogColor',
+            scene.fogColor
+        );
     }
 
     /**
@@ -52,47 +91,69 @@ export class TextFogPlugin extends MaterialPluginBase {
     }
 
     /**
-     * Inject shader code to apply fog to emissive color
+     * Inject shader code to calculate fog distance and apply fog blending
      * @param {string} shaderType - 'vertex' or 'fragment'
      */
     getCustomCode(shaderType) {
+        if (shaderType === 'vertex') {
+            return {
+                // Declare our varying for fog distance
+                'CUSTOM_VERTEX_DEFINITIONS': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    varying vec3 textFogDistance;
+                    #endif
+                `,
+                // Calculate fog distance in view space at end of vertex shader
+                // finalWorld and positionUpdated are Babylon's built-in variables
+                'CUSTOM_VERTEX_MAIN_END': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    vec4 textWorldPos = finalWorld * vec4(positionUpdated, 1.0);
+                    textFogDistance = (view * textWorldPos).xyz;
+                    #endif
+                `
+            };
+        }
+
         if (shaderType === 'fragment') {
             return {
-                // This injection point runs just before gl_FragColor is finalized
-                // At this point, standard fog has been applied to diffuse/ambient
-                // but emissive contribution bypasses fog, so we re-apply fog
-                // to the entire output to properly fade text into fog
+                // Declare uniforms and varying in fragment shader
+                'CUSTOM_FRAGMENT_DEFINITIONS': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    uniform vec4 textFogInfos;
+                    uniform vec3 textFogColor;
+                    varying vec3 textFogDistance;
+                    #endif
+                `,
+                // Apply fog to the entire fragment color before final output
+                // This runs just before gl_FragColor is set
                 'CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR': `
                     #ifdef MESHWRITER_TEXT_FOG
-                    #ifdef FOG
-                    // Recalculate fog for the full fragment color including emissive
-                    // vFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
-                    // vFogColor: fog RGB color
-                    // vFogDistance: vec3 distance from camera (set by vertex shader)
+                    // textFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
+                    // Fog modes: 1=LINEAR, 2=EXP, 3=EXP2
 
                     float textFogFactor = 1.0;
-                    float textFogDist = length(vFogDistance);
+                    float textFogDist = length(textFogDistance);
 
-                    if (FOGMODE_LINEAR == vFogInfos.x) {
+                    if (textFogInfos.x == 1.0) {
                         // Linear fog: factor = (end - dist) / (end - start)
-                        textFogFactor = clamp((vFogInfos.z - textFogDist) / (vFogInfos.z - vFogInfos.y), 0.0, 1.0);
-                    } else if (FOGMODE_EXP == vFogInfos.x) {
+                        textFogFactor = clamp((textFogInfos.z - textFogDist) / (textFogInfos.z - textFogInfos.y), 0.0, 1.0);
+                    } else if (textFogInfos.x == 2.0) {
                         // Exponential fog: factor = exp(-dist * density)
-                        textFogFactor = clamp(exp(-textFogDist * vFogInfos.w), 0.0, 1.0);
-                    } else if (FOGMODE_EXP2 == vFogInfos.x) {
+                        textFogFactor = clamp(exp(-textFogDist * textFogInfos.w), 0.0, 1.0);
+                    } else if (textFogInfos.x == 3.0) {
                         // Exponential squared fog: factor = exp(-(dist * density)^2)
-                        float fogDistDensity = textFogDist * vFogInfos.w;
+                        float fogDistDensity = textFogDist * textFogInfos.w;
                         textFogFactor = clamp(exp(-fogDistDensity * fogDistDensity), 0.0, 1.0);
                     }
 
-                    // Blend the entire fragment (including emissive) toward fog color
+                    // Blend the entire fragment (diffuse + emissive) toward fog color
                     // textFogFactor: 1.0 = no fog (full color), 0.0 = full fog
-                    color.rgb = mix(vFogColor, color.rgb, textFogFactor);
+                    color.rgb = mix(textFogColor, color.rgb, textFogFactor);
                     #endif
-                    #endif
-                `,
+                `
             };
         }
+
         return null;
     }
 }

package/src/material.js

@@ -61,15 +61,17 @@ export function makeMaterial(scene, letters, emissive, ambient, specular, diffus
     // Emissive-only materials should be self-lit and not affected by fog
     if (emissiveOnly) {
         material.fogEnabled = false;
+    } else if (fogEnabled) {
+        // IMPORTANT: Disable Babylon's built-in fog when using TextFogPlugin.
+        // Built-in fog only affects diffuse/ambient, not emissive.
+        // If we left fogEnabled=true, diffuse would be fogged twice (once by Babylon,
+        // once by the plugin), while emissive would only be fogged once by the plugin.
+        // By disabling built-in fog and handling ALL fog in the plugin, we get uniform
+        // fog application to the entire fragment (matching terrain behavior).
+        material.fogEnabled = false;
+        material._textFogPlugin = new TextFogPlugin(material);
     } else {
-        material.fogEnabled = fogEnabled;
-        // Attach fog plugin to properly blend emissive color with fog
-        // Babylon's standard fog only affects diffuse/ambient, not emissive.
-        // The plugin re-fogs the entire fragment output so emissive fades properly.
-        // (The slight double-fog on diffuse/ambient is negligible since text is primarily emissive)
-        if (fogEnabled) {
-            material._textFogPlugin = new TextFogPlugin(material);
-        }
+        material.fogEnabled = false;
     }
 
     return material;
@@ -95,7 +97,8 @@ export function makeFaceMaterial(scene, letters, emissive, opac, fogEnabled = tr
     material.disableLighting = true;
     material.alpha = opac;
     material.backFaceCulling = false;
-    material.fogEnabled = fogEnabled;
+    // Disable Babylon's built-in fog - TextFogPlugin handles all fog uniformly
+    material.fogEnabled = false;
     if (fogEnabled) {
         material._textFogPlugin = new TextFogPlugin(material);
     }

package/dist/index.d.ts

@@ -1,295 +0,0 @@
-/**
- * MeshWriter Type Declarations
- * Provides TypeScript types for MeshWriter library
- *
- * Requires: @babylonjs/core (peer dependency)
- */
-
-import type { Scene } from '@babylonjs/core/scene';
-import type { Mesh } from '@babylonjs/core/Meshes/mesh';
-import type { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import type { SolidParticleSystem } from '@babylonjs/core/Particles/solidParticleSystem';
-import type { Vector2 } from '@babylonjs/core/Maths/math.vector';
-
-// ============ Options & Configuration Types ============
-
-/** Position configuration for text placement */
-export interface MeshWriterPosition {
-    x?: number;
-    y?: number;
-    z?: number;
-}
-
-/** Color configuration for material properties */
-export interface MeshWriterColors {
-    diffuse?: string;
-    specular?: string;
-    ambient?: string;
-    emissive?: string;
-}
-
-/** Options for creating text with MeshWriter */
-export interface MeshWriterOptions {
-    /** Position of the text in 3D space */
-    position?: MeshWriterPosition;
-    /** Material color properties */
-    colors?: MeshWriterColors;
-    /** Font family name (must be registered first) */
-    'font-family'?: string;
-    /** Text anchor point */
-    anchor?: 'left' | 'right' | 'center';
-    /** Height of letters in world units */
-    'letter-height'?: number;
-    /** Thickness (depth) of letters in world units */
-    'letter-thickness'?: number;
-    /** Emissive color as hex string (e.g., "#FF0000") */
-    color?: string;
-    /** Material alpha/transparency (0-1) */
-    alpha?: number;
-    /** If true, disables lighting (only emissive color shows) - gives self-lit appearance */
-    'emissive-only'?: boolean;
-    /** If true, the material is affected by scene fog (default: true) */
-    'fog-enabled'?: boolean;
-}
-
-/** Babylon namespace subset used for CSG injection */
-export interface BabylonCSGNamespace {
-    CSG?: unknown;
-    CSG2?: unknown;
-    InitializeCSG2Async?: () => void | Promise<void>;
-    IsCSG2Ready?: () => boolean;
-}
-
-/** Preferences for initializing MeshWriter */
-export interface MeshWriterPreferences {
-    /** Default font family name */
-    defaultFont?: string;
-    /** Scale factor for all text */
-    scale?: number;
-    /** Origin point for mesh positioning */
-    meshOrigin?: 'letterCenter' | 'fontOrigin';
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Babylon namespace providing CSG helpers (used for ES module builds) */
-    babylon?: BabylonCSGNamespace;
-}
-
-// ============ Instance Types ============
-
-/** A text instance created by MeshWriter */
-export interface MeshWriterInstance {
-    /** Get the SolidParticleSystem containing letter meshes */
-    getSPS(): SolidParticleSystem | undefined;
-    /** Get the combined mesh containing all letters */
-    getMesh(): Mesh | undefined;
-    /** Get the material applied to the text */
-    getMaterial(): StandardMaterial;
-    /** Get the X offset for anchoring */
-    getOffsetX(): number;
-    /** Get bounding boxes for each letter */
-    getLettersBoxes(): number[][];
-    /** Get origin positions for each letter */
-    getLettersOrigins(): number[][];
-    /** Get or set the emissive color */
-    color(c?: string): string;
-    /** Get or set the alpha value */
-    alpha(a?: number): number;
-    /** Update the emissive color */
-    setColor(color: string): void;
-    /** Update the alpha value */
-    setAlpha(alpha: number): void;
-    /** Temporarily override alpha */
-    overrideAlpha(alpha: number): void;
-    /** Reset alpha to original value */
-    resetAlpha(): void;
-    /** Get the center position of a letter by index */
-    getLetterCenter(ix: number): Vector2;
-    /** Check if this instance has been disposed */
-    isDisposed(): boolean;
-    /** Dispose of all meshes and materials */
-    dispose(): void;
-}
-
-/** Constructor function returned by MeshWriter factory */
-export interface MeshWriterConstructor {
-    new (letters: string, options?: MeshWriterOptions): MeshWriterInstance;
-    (letters: string, options?: MeshWriterOptions): MeshWriterInstance;
-}
-
-// ============ Font Types ============
-
-/** Individual glyph specification */
-export interface GlyphSpec {
-    /** Compressed shape command strings (pre-decompression) */
-    sC?: string[];
-    /** Compressed hole command strings - array of holes, each hole is array of command strings */
-    hC?: string[][];
-    /** Decompressed shape commands (post-decompression, internal use) */
-    shapeCmds?: number[][][];
-    /** Decompressed hole commands (post-decompression, internal use) */
-    holeCmds?: number[][][][];
-    /** Minimum X coordinate of bounding box */
-    xMin: number;
-    /** Maximum X coordinate of bounding box */
-    xMax: number;
-    /** Minimum Y coordinate of bounding box */
-    yMin: number;
-    /** Maximum Y coordinate of bounding box */
-    yMax: number;
-    /** Character advance width */
-    wdth: number;
-    /** X coordinate scale factor (optional) */
-    xFactor?: number;
-    /** Y coordinate scale factor (optional) */
-    yFactor?: number;
-    /** X coordinate shift (optional) */
-    xShift?: number;
-    /** Y coordinate shift (optional) */
-    yShift?: number;
-    /** Per-glyph reverse shape override (optional) */
-    reverseShape?: boolean;
-    /** Per-glyph reverse hole override (optional) */
-    reverseHole?: boolean;
-}
-
-/** Font specification object containing glyph data */
-export interface FontSpec {
-    /** Whether to reverse hole winding (default for all glyphs) */
-    reverseHoles: boolean;
-    /** Whether to reverse shape winding (default for all glyphs) */
-    reverseShapes: boolean;
-    /** Character glyph data - indexed by character */
-    [character: string]: GlyphSpec | boolean;
-}
-
-/**
- * Function that creates font spec from codeList encoder
- * @deprecated Use FontSpec directly instead of FontFactory
- */
-export type FontFactory = (codeList: (list: number[][]) => string) => FontSpec;
-
-/** Font data - either a FontSpec object or a FontFactory function (legacy) */
-export type FontData = FontSpec | FontFactory;
-
-// ============ Main API Types ============
-
-/** CSG version used for boolean operations */
-export type CSGVersion = 'CSG' | 'CSG2' | null;
-
-/** MeshWriter static API */
-export interface MeshWriterStatic {
-    /**
-     * Create a MeshWriter constructor asynchronously (required for Babylon 8+)
-     * Initializes CSG2 before returning
-     */
-    createAsync(scene: Scene, preferences?: MeshWriterPreferences): Promise<MeshWriterConstructor>;
-
-    /**
-     * Create a MeshWriter constructor synchronously (legacy, Babylon < 7.31)
-     * @deprecated Use createAsync for Babylon 8+
-     */
-    create(scene: Scene, preferences?: MeshWriterPreferences): MeshWriterConstructor;
-
-    /** Check if CSG is initialized and ready */
-    isReady(): boolean;
-
-    /** Get the CSG version being used */
-    getCSGVersion(): CSGVersion;
-
-    /** Set a custom CSG2 initializer function */
-    setCSGInitializer(init: () => void | Promise<void>): void;
-
-    /** Set a custom CSG ready check function */
-    setCSGReadyCheck(check: () => boolean): void;
-
-    /** Register a callback to run when CSG is ready */
-    onCSGReady(callback: () => void): void;
-
-    /** Manually mark CSG as ready */
-    markCSGReady(): void;
-    /** Initialize the internal CSG module with Babylon helpers */
-    initCSGModule(babylon: BabylonCSGNamespace): void;
-
-    /** Register a font for use with MeshWriter */
-    registerFont(name: string, fontData: FontData): void;
-
-    /** Register multiple font aliases pointing to the same font */
-    registerFontAliases(targetName: string, ...aliases: string[]): void;
-
-    /** Get a registered font by name */
-    getFont(name: string): FontSpec | undefined;
-
-    /** Check if a font is registered */
-    isFontRegistered(name: string): boolean;
-
-    /** Encode font coordinates to compressed string */
-    codeList(list: number[][]): string;
-
-    /** Decode compressed string to font coordinates */
-    decodeList(encoded: string): number[][];
-}
-
-// ============ Exports ============
-
-/** Main MeshWriter object with all static methods */
-export const MeshWriter: MeshWriterStatic;
-
-/** Create a MeshWriter constructor asynchronously */
-export function createMeshWriterAsync(scene: Scene, preferences?: MeshWriterPreferences): Promise<MeshWriterConstructor>;
-
-/** Create a MeshWriter constructor synchronously (legacy) */
-export function createMeshWriter(scene: Scene, preferences?: MeshWriterPreferences): MeshWriterConstructor;
-
-/** Check if CSG is initialized and ready */
-export function isCSGReady(): boolean;
-
-/** Get the CSG version being used */
-export function getCSGVersion(): CSGVersion;
-
-/** Set a custom CSG2 initializer function */
-export function setCSGInitializer(init: () => void | Promise<void>): void;
-
-/** Set a custom CSG ready check function */
-export function setCSGReadyCheck(check: () => boolean): void;
-
-/** Register a callback to run when CSG is ready */
-export function onCSGReady(callback: () => void): void;
-
-/** Manually mark CSG as ready */
-export function markCSGReady(): void;
-
-/** Register a font for use with MeshWriter */
-export function registerFont(name: string, fontData: FontData): void;
-
-/** Register multiple font aliases */
-export function registerFontAliases(targetName: string, ...aliases: string[]): void;
-
-/** Get a registered font by name */
-export function getFont(name: string): FontSpec | undefined;
-
-/** Check if a font is registered */
-export function isFontRegistered(name: string): boolean;
-
-/** Encode font coordinates to compressed string */
-export function codeList(list: number[][]): string;
-
-/** Decode compressed string to font coordinates */
-export function decodeList(encoded: string): number[][];
-
-/** Get list of registered font names */
-export function getRegisteredFonts(): string[];
-
-/** Unregister a font (primarily for testing) */
-export function unregisterFont(name: string): void;
-
-/** Clear all registered fonts (primarily for testing) */
-export function clearFonts(): void;
-
-/** Encode font coordinates (alias of codeList) */
-export function encodeFontData(list: number[][]): string;
-
-/** Decode font coordinates (alias of decodeList) */
-export function decodeFontData(encoded: string): number[][];
-
-/** Initialize the internal CSG module with Babylon helpers */
-export function initCSGModule(babylon: BabylonCSGNamespace): void;

package/dist/src/variableFontCache.d.ts

@@ -1,56 +0,0 @@
-/**
- * Create a cache key for a glyph at a specific weight
- * @param {number} weight - Font weight value
- * @param {string} char - Character
- * @returns {string} - Cache key
- */
-export function createGlyphCacheKey(weight: number, char: string): string;
-/**
- * MeshWriter Variable Font Cache
- * LRU cache for variable font glyphs to prevent memory bloat
- */
-/**
- * LRU Cache for glyph specifications
- * Prevents memory bloat when using many weight variations
- */
-export class GlyphCache {
-    /**
-     * Create a new glyph cache
-     * @param {number} [maxSize=5000] - Maximum number of cached entries
-     */
-    constructor(maxSize?: number);
-    _maxSize: number;
-    _cache: Map<any, any>;
-    /**
-     * Get a cached value (moves it to most recently used)
-     * @param {string} key - Cache key
-     * @returns {*} - Cached value or undefined
-     */
-    get(key: string): any;
-    /**
-     * Set a cache value (evicts oldest if at capacity)
-     * @param {string} key - Cache key
-     * @param {*} value - Value to cache
-     */
-    set(key: string, value: any): void;
-    /**
-     * Check if key exists in cache
-     * @param {string} key - Cache key
-     * @returns {boolean}
-     */
-    has(key: string): boolean;
-    /**
-     * Clear all cached entries
-     */
-    clear(): void;
-    /**
-     * Get current cache size
-     * @returns {number}
-     */
-    get size(): number;
-    /**
-     * Get maximum cache size
-     * @returns {number}
-     */
-    get maxSize(): number;
-}

package/dist/src/variableFontConverter.d.ts

@@ -1,21 +0,0 @@
-/**
- * MeshWriter Variable Font Converter
- * Converts fontkit glyph paths to MeshWriter FontSpec format at runtime
- */
-/**
- * Convert fontkit glyph to MeshWriter GlyphSpec
- * @param {object} glyph - fontkit glyph object
- * @param {number} [scale=1] - Scale factor
- * @returns {object|null} - GlyphSpec with shapeCmds/holeCmds, or null if empty
- */
-export function convertFontkitGlyphToSpec(glyph: object, scale?: number): object | null;
-/**
- * Extract kerning pairs from fontkit font for given character set
- * @param {object} font - fontkit font object
- * @param {string} charset - Characters to extract kerning for
- * @param {number} [scale=1] - Scale factor
- * @returns {object} - Kerning table mapping "char1,char2" to adjustment value
- */
-export function extractFontkitKerningPairs(font: object, charset: string, scale?: number): object;
-export function convertGlyphToSpec(glyph: any, scale?: number): any;
-export function extractKerningPairs(font: any, charset: any, scale?: number): any;