meshwriter-cudu 3.0.0

package/src/csg.js

@@ -0,0 +1,220 @@
+/**
+ * MeshWriter CSG Module
+ * Handles CSG version detection, async initialization, and ready state management
+ */
+
+import { isObject, isPromiseLike } from './utils.js';
+import {
+    CSG as BabylonCSG,
+    CSG2 as BabylonCSG2,
+    InitializeCSG2Async as BabylonInitializeCSG2Async,
+    IsCSG2Ready as BabylonIsCSG2Ready
+} from './babylonImports.js';
+
+// CSG libraries - initialized from Babylon imports or external source
+let CSG = BabylonCSG;
+let CSG2 = BabylonCSG2;
+let InitializeCSG2Async = BabylonInitializeCSG2Async;
+let IsCSG2Ready = BabylonIsCSG2Ready;
+
+// State
+let csgVersion = null;        // 'CSG2', 'CSG', or null
+let csgReady = false;
+const csgReadyListeners = [];
+let externalCSGInitializer = null;
+let externalCSGReadyCheck = null;
+
+/**
+ * Initialize CSG module with Babylon.js CSG classes
+ * Must be called before using any CSG functionality
+ * @param {Object} babylon - Object containing CSG, CSG2, InitializeCSG2Async, IsCSG2Ready
+ */
+export function initCSGModule(babylon) {
+    if (isObject(babylon)) {
+        CSG = babylon.CSG || null;
+        CSG2 = babylon.CSG2 || null;
+        InitializeCSG2Async = babylon.InitializeCSG2Async || null;
+        IsCSG2Ready = babylon.IsCSG2Ready || null;
+    }
+    csgVersion = detectCSGVersion();
+
+    // Legacy CSG is immediately ready
+    if (csgVersion === 'CSG') {
+        markCSGInitialized();
+    } else if (csgVersion === 'CSG2') {
+        // Check if CSG2 is already initialized
+        csgReady = false;
+        if (runCSGReadyCheck()) {
+            markCSGInitialized();
+        }
+    }
+}
+
+/**
+ * Detect which CSG implementation is available
+ * @returns {'CSG2'|'CSG'|null}
+ */
+export function detectCSGVersion() {
+    // Prefer CSG2 (Babylon 7.31+)
+    if (isObject(CSG2) && typeof InitializeCSG2Async === 'function') {
+        return 'CSG2';
+    }
+    // Fall back to legacy CSG
+    if (isObject(CSG) && typeof CSG.FromMesh === 'function') {
+        return 'CSG';
+    }
+    return null;
+}
+
+/**
+ * Mark CSG as ready and notify all listeners
+ */
+export function markCSGInitialized() {
+    if (csgReady) {
+        return;
+    }
+    csgReady = true;
+
+    // Notify all waiting listeners
+    if (csgReadyListeners.length) {
+        csgReadyListeners.splice(0).forEach(function(listener) {
+            try {
+                listener();
+            } catch (err) {
+                console.error("MeshWriter: onCSGReady listener failed", err);
+            }
+        });
+    }
+}
+
+/**
+ * Check if CSG is ready for use
+ * @returns {boolean}
+ */
+export function isCSGReady() {
+    if (csgVersion === 'CSG2') {
+        refreshCSGReadyState();
+        return csgReady;
+    }
+    return csgVersion === 'CSG';
+}
+
+/**
+ * Refresh CSG2 ready state from external checks
+ */
+function refreshCSGReadyState() {
+    if (csgVersion !== 'CSG2' || csgReady) {
+        return;
+    }
+    if (runCSGReadyCheck()) {
+        markCSGInitialized();
+    }
+}
+
+/**
+ * Run CSG ready check (external or native)
+ */
+function runCSGReadyCheck() {
+    // Try external ready check first
+    if (typeof externalCSGReadyCheck === "function") {
+        try {
+            if (externalCSGReadyCheck()) {
+                return true;
+            }
+        } catch (err) {
+            console.warn("MeshWriter: external CSG ready check failed", err);
+        }
+    }
+
+    // Check native IsCSG2Ready
+    if (typeof IsCSG2Ready === "function" && IsCSG2Ready()) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Initialize CSG2 asynchronously
+ * @returns {Promise<void>}
+ */
+export async function initializeCSG2() {
+    if (csgVersion !== 'CSG2') {
+        return;
+    }
+    if (csgReady) {
+        return;
+    }
+
+    const initializer = externalCSGInitializer || InitializeCSG2Async;
+    if (typeof initializer !== "function") {
+        throw new Error(
+            "MeshWriter: No CSG2 initializer available. " +
+            "Use MeshWriter.setCSGInitializer() or ensure BABYLON.InitializeCSG2Async is available."
+        );
+    }
+
+    const result = initializer();
+    if (isPromiseLike(result)) {
+        await result;
+    }
+    markCSGInitialized();
+}
+
+// Public API
+
+/**
+ * Get the current CSG version being used
+ * @returns {'CSG2'|'CSG'|null}
+ */
+export function getCSGVersion() {
+    return csgVersion;
+}
+
+/**
+ * Set an external CSG2 initializer function
+ * @param {Function} fn - Async function that initializes CSG2
+ */
+export function setCSGInitializer(fn) {
+    if (typeof fn === "function") {
+        externalCSGInitializer = fn;
+    }
+}
+
+/**
+ * Set an external CSG2 ready check function
+ * @param {Function} fn - Function that returns true when CSG2 is ready
+ */
+export function setCSGReadyCheck(fn) {
+    if (typeof fn === "function") {
+        externalCSGReadyCheck = fn;
+        refreshCSGReadyState();
+    }
+}
+
+/**
+ * Register a callback to be called when CSG is ready
+ * If CSG is already ready, callback is called immediately
+ * @param {Function} listener
+ */
+export function onCSGReady(listener) {
+    if (typeof listener !== "function") {
+        return;
+    }
+    if (isCSGReady()) {
+        listener();
+    } else {
+        csgReadyListeners.push(listener);
+    }
+}
+
+/**
+ * Get the CSG library to use for operations
+ * @returns {Object} - CSG or CSG2 class
+ */
+export function getCSGLib() {
+    return csgVersion === 'CSG2' ? CSG2 : CSG;
+}
+
+// Export for direct access when needed
+export { CSG, CSG2 };

package/src/curves.js

@@ -0,0 +1,67 @@
+/**
+ * MeshWriter Curve Extensions
+ * Optimized Path2 curve methods for better performance
+ */
+
+import { Path2, Curve3, Vector3 } from './babylonImports.js';
+
+/**
+ * Extended Path2 interface with MeshWriter curve methods
+ * @typedef {Object} Path2Extensions
+ * @property {(redX: number, redY: number, blueX: number, blueY: number) => Path2} addQuadraticCurveTo
+ * @property {(redX: number, redY: number, greenX: number, greenY: number, blueX: number, blueY: number) => Path2} addCubicCurveTo
+ */
+
+// Optimized segment count for curves
+// Native Babylon 6+ uses 36 segments which causes slowdown
+// MeshWriter uses 6 for better performance
+export const curveSampleSize = 6;
+
+/**
+ * Install optimized curve methods on Path2 prototype
+ * Must be called after Babylon.js is loaded
+ */
+export function installCurveExtensions() {
+    if (!Path2 || !Path2.prototype) {
+        return;
+    }
+
+    /** @type {any} */
+    const proto = Path2.prototype;
+
+    // Quadratic Bezier with optimized segment count
+    proto.addQuadraticCurveTo = function(redX, redY, blueX, blueY) {
+        const points = this.getPoints();
+        const lastPoint = points[points.length - 1];
+        const origin = new Vector3(lastPoint.x, lastPoint.y, 0);
+        const control = new Vector3(redX, redY, 0);
+        const destination = new Vector3(blueX, blueY, 0);
+
+        const curve = Curve3.CreateQuadraticBezier(origin, control, destination, curveSampleSize);
+        const curvePoints = curve.getPoints();
+
+        for (let i = 1; i < curvePoints.length; i++) {
+            this.addLineTo(curvePoints[i].x, curvePoints[i].y);
+        }
+        return this; // Return this for method chaining
+    };
+
+    // Cubic Bezier with optimized segment count
+    proto.addCubicCurveTo = function(redX, redY, greenX, greenY, blueX, blueY) {
+        const points = this.getPoints();
+        const lastPoint = points[points.length - 1];
+        const origin = new Vector3(lastPoint.x, lastPoint.y, 0);
+        const control1 = new Vector3(redX, redY, 0);
+        const control2 = new Vector3(greenX, greenY, 0);
+        const destination = new Vector3(blueX, blueY, 0);
+
+        const nbPoints = Math.floor(0.3 + curveSampleSize * 1.5);
+        const curve = Curve3.CreateCubicBezier(origin, control1, control2, destination, nbPoints);
+        const curvePoints = curve.getPoints();
+
+        for (let i = 1; i < curvePoints.length; i++) {
+            this.addLineTo(curvePoints[i].x, curvePoints[i].y);
+        }
+        return this; // Return this for method chaining
+    };
+}

package/src/fogPlugin.js

@@ -0,0 +1,98 @@
+/**
+ * TextFogPlugin - MaterialPluginBase that applies fog to emissive color
+ *
+ * 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.
+ */
+
+import { MaterialPluginBase } from './babylonImports.js';
+
+/**
+ * Plugin that applies scene fog to text materials by modifying
+ * the final fragment color before output.
+ */
+export class TextFogPlugin extends MaterialPluginBase {
+    /**
+     * @param {import('@babylonjs/core/Materials/material').Material} material
+     */
+    constructor(material) {
+        var priority = 300; // Run after standard material processing
+        var defines = { 'MESHWRITER_TEXT_FOG': false };
+        super(material, 'TextFogPlugin', priority, defines);
+        this._enable(true);
+    }
+
+    /**
+     * Set the define based on whether scene fog is enabled
+     * @param {object} defines
+     * @param {import('@babylonjs/core/scene').Scene} scene
+     * @param {import('@babylonjs/core/Meshes/mesh').Mesh} mesh
+     */
+    prepareDefines(defines, scene, mesh) {
+        // Enable when scene has any fog mode set (1=LINEAR, 2=EXP, 3=EXP2)
+        defines['MESHWRITER_TEXT_FOG'] = scene.fogMode !== 0;
+    }
+
+    getClassName() {
+        return 'TextFogPlugin';
+    }
+
+    getUniforms() {
+        // We use Babylon's built-in fog uniforms (vFogInfos, vFogColor)
+        // which are already available in the standard material
+        return { ubo: [] };
+    }
+
+    /**
+     * Clean up the plugin
+     */
+    dispose() {
+        super.dispose();
+    }
+
+    /**
+     * Inject shader code to apply fog to emissive color
+     * @param {string} shaderType - 'vertex' or 'fragment'
+     */
+    getCustomCode(shaderType) {
+        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
+                '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)
+
+                    float textFogFactor = 1.0;
+                    float textFogDist = length(vFogDistance);
+
+                    if (FOGMODE_LINEAR == vFogInfos.x) {
+                        // 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) {
+                        // Exponential fog: factor = exp(-dist * density)
+                        textFogFactor = clamp(exp(-textFogDist * vFogInfos.w), 0.0, 1.0);
+                    } else if (FOGMODE_EXP2 == vFogInfos.x) {
+                        // Exponential squared fog: factor = exp(-(dist * density)^2)
+                        float fogDistDensity = textFogDist * vFogInfos.w;
+                        textFogFactor = clamp(exp(-fogDistDensity * fogDistDensity), 0.0, 1.0);
+                    }
+
+                    // Blend the entire fragment (including emissive) toward fog color
+                    // textFogFactor: 1.0 = no fog (full color), 0.0 = full fog
+                    color.rgb = mix(vFogColor, color.rgb, textFogFactor);
+                    #endif
+                    #endif
+                `,
+            };
+        }
+        return null;
+    }
+}

package/src/fontCompression.js

@@ -0,0 +1,141 @@
+/**
+ * MeshWriter Font Compression/Decompression
+ * Base-128 encoding for font data compression (~50% size reduction)
+ */
+
+import { isArray } from './utils.js';
+
+const floor = Math.floor;
+
+// Encoding arrays (initialized once at module load)
+let b128back;
+let b128digits;
+
+/**
+ * Initialize encoding arrays for base-128 conversion
+ * Called once when module loads
+ */
+function prepArray() {
+    let pntr = -1;
+    let n;
+    b128back = new Uint8Array(256);
+    b128digits = new Array(128);
+
+    while (160 > pntr++) {
+        if (pntr < 128) {
+            n = fr128to256(pntr);
+            b128digits[pntr] = String.fromCharCode(n);
+            b128back[n] = pntr;
+        } else {
+            if (pntr === 128) {
+                b128back[32] = pntr;
+            } else {
+                b128back[pntr + 71] = pntr;
+            }
+        }
+    }
+
+    function fr128to256(n) {
+        if (n < 92) {
+            return n < 58 ? n < 6 ? n + 33 : n + 34 : n + 35;
+        } else {
+            return n + 69;
+        }
+    }
+}
+
+// Initialize on module load
+prepArray();
+
+/**
+ * Convert base-128 encoded string to number
+ */
+function frB128(s) {
+    let result = 0;
+    let i = -1;
+    const l = s.length - 1;
+    while (i++ < l) {
+        result = result * 128 + b128back[s.charCodeAt(i)];
+    }
+    return result;
+}
+
+/**
+ * Convert number to base-128 encoded string
+ */
+function toB128(i) {
+    let s = b128digits[(i % 128)];
+    i = floor(i / 128);
+    while (i > 0) {
+        s = b128digits[(i % 128)] + s;
+        i = floor(i / 128);
+    }
+    return s;
+}
+
+/**
+ * Decode a compressed command list string
+ * @param {string} str - Compressed string (space-separated encoded commands)
+ * @returns {Array} - Array of decoded command arrays
+ */
+export function decodeList(str) {
+    const split = str.split(" ");
+    const list = [];
+
+    split.forEach(function(cmds) {
+        if (cmds.length === 12) { list.push(decode6(cmds)); }
+        if (cmds.length === 8) { list.push(decode4(cmds)); }
+        if (cmds.length === 4) { list.push(decode2(cmds)); }
+    });
+
+    return list;
+
+    function decode6(s) {
+        return [
+            decode1(s, 0, 2), decode1(s, 2, 4), decode1(s, 4, 6),
+            decode1(s, 6, 8), decode1(s, 8, 10), decode1(s, 10, 12)
+        ];
+    }
+    function decode4(s) {
+        return [decode1(s, 0, 2), decode1(s, 2, 4), decode1(s, 4, 6), decode1(s, 6, 8)];
+    }
+    function decode2(s) {
+        return [decode1(s, 0, 2), decode1(s, 2, 4)];
+    }
+    function decode1(s, start, end) {
+        return (frB128(s.substring(start, end)) - 4000) / 2;
+    }
+}
+
+/**
+ * Encode a command list to compressed string
+ * @param {Array} list - Array of command arrays
+ * @returns {string} - Compressed string
+ */
+export function codeList(list) {
+    let str = "";
+    let xtra = "";
+
+    if (isArray(list)) {
+        list.forEach(function(cmds) {
+            if (cmds.length === 6) { str += xtra + code6(cmds); xtra = " "; }
+            if (cmds.length === 4) { str += xtra + code4(cmds); xtra = " "; }
+            if (cmds.length === 2) { str += xtra + code2(cmds); xtra = " "; }
+        });
+    }
+
+    return str;
+
+    function code6(a) {
+        return code1(a[0]) + code1(a[1]) + code1(a[2]) + code1(a[3]) + code1(a[4]) + code1(a[5]);
+    }
+    function code4(a) {
+        return code1(a[0]) + code1(a[1]) + code1(a[2]) + code1(a[3]);
+    }
+    function code2(a) {
+        return code1(a[0]) + code1(a[1]);
+    }
+    function code1(n) {
+        return toB128((n + n) + 4000);
+    }
+}

package/src/fontRegistry.js

@@ -0,0 +1,98 @@
+/**
+ * MeshWriter Font Registry
+ * Manages font registration and lookup
+ */
+
+import { isObject } from './utils.js';
+import { codeList, decodeList } from './fontCompression.js';
+
+// Private font storage
+const FONTS = {};
+
+/**
+ * Register a font for use with MeshWriter
+ * @param {string} name - Font name (case-sensitive, used in "font-family" option)
+ * @param {Function|Object} fontData - Font factory function or pre-initialized font object
+ *
+ * @example
+ * // Register a font factory (receives codeList for encoding)
+ * import helvetica from 'meshwriter/fonts/helvetica';
+ * registerFont('Helvetica', helvetica);
+ *
+ * // Register with aliases
+ * registerFont('Arial', helvetica);
+ * registerFont('sans-serif', helvetica);
+ */
+export function registerFont(name, fontData) {
+    if (typeof fontData === 'function') {
+        // Font is a factory function expecting codeList
+        FONTS[name] = fontData(codeList);
+    } else if (isObject(fontData)) {
+        // Font is already initialized
+        FONTS[name] = fontData;
+    } else {
+        throw new Error(`MeshWriter: Invalid font data for "${name}"`);
+    }
+}
+
+/**
+ * Register multiple font aliases pointing to the same font
+ * @param {string} targetName - Name of already-registered font
+ * @param {...string} aliases - Alias names to register
+ *
+ * @example
+ * registerFont('Helvetica', helveticaData);
+ * registerFontAliases('Helvetica', 'Arial', 'sans-serif');
+ */
+export function registerFontAliases(targetName, ...aliases) {
+    if (!FONTS[targetName]) {
+        throw new Error(`MeshWriter: Cannot create aliases: font "${targetName}" not registered`);
+    }
+    aliases.forEach(alias => {
+        FONTS[alias] = FONTS[targetName];
+    });
+}
+
+/**
+ * Get a registered font by name
+ * @param {string} name - Font name
+ * @returns {Object|undefined} - Font object or undefined if not found
+ */
+export function getFont(name) {
+    return FONTS[name];
+}
+
+/**
+ * Check if a font is registered
+ * @param {string} name - Font name
+ * @returns {boolean}
+ */
+export function isFontRegistered(name) {
+    return isObject(FONTS[name]);
+}
+
+/**
+ * Get list of all registered font names
+ * @returns {string[]}
+ */
+export function getRegisteredFonts() {
+    return Object.keys(FONTS);
+}
+
+/**
+ * Unregister a font (mainly for testing)
+ * @param {string} name - Font name to remove
+ */
+export function unregisterFont(name) {
+    delete FONTS[name];
+}
+
+/**
+ * Clear all registered fonts (mainly for testing)
+ */
+export function clearFonts() {
+    Object.keys(FONTS).forEach(key => delete FONTS[key]);
+}
+
+// Re-export compression utilities for font authors
+export { codeList, decodeList };

package/src/globals.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Global type declarations for MeshWriter UMD builds
+ * Include this file if using MeshWriter via script tag
+ */
+
+import type { MeshWriterStatic } from './types';
+
+declare global {
+    /** Global MeshWriter (UMD bundle) */
+    var MeshWriter: MeshWriterStatic | undefined;
+    /** Legacy name for MeshWriter (UMD bundle) */
+    var TYPE: MeshWriterStatic | undefined;
+
+    namespace BABYLON {
+        /** MeshWriter attached to BABYLON namespace (UMD bundle) */
+        var MeshWriter: MeshWriterStatic | undefined;
+    }
+}
+
+export {};