meshwriter-cudu 3.0.0

package/fonts/webgl-dings.js

@@ -0,0 +1,113 @@
+/**
+ * Webgl-dings Font for MeshWriter
+ * Pre-initialized FontSpec format
+ * @type {import("../src/types").FontSpec}
+ */
+export default {
+    reverseHoles: false,
+    reverseShapes: true,
+    "4": {
+        sC: [],
+        xMin: 24,
+        xMax: 522,
+        yMin: 0,
+        yMax: 700,
+        wdth: 556
+    },
+    "5": {
+        sC: [],
+        xMin: 34,
+        xMax: 522,
+        yMin: -14,
+        yMax: 700,
+        wdth: 556
+    },
+    "A": {
+        sC: [],
+        xMin: -7,
+        xMax: 675,
+        yMin: 0,
+        yMax: 714,
+        wdth: 667
+    },
+    "B": {
+        sC: [],
+        xMin: 76,
+        xMax: 667,
+        yMin: 0,
+        yMax: 714,
+        wdth: 704
+    },
+    "X": {
+        sC: [],
+        xMin: -3,
+        xMax: 651,
+        yMin: 0,
+        yMax: 714,
+        wdth: 648
+    },
+    "Y": {
+        sC: [],
+        xMin: -6,
+        xMax: 654,
+        yMin: 0,
+        yMax: 714,
+        wdth: 648
+    },
+    "Z": {
+        sC: [],
+        xMin: 23,
+        xMax: 976.5,
+        yMin: -139.5,
+        yMax: 812,
+        wdth: 999.5
+    },
+    "a": {
+        sC: [],
+        xMin: -340,
+        xMax: 340,
+        yMin: 47,
+        yMax: 806,
+        wdth: 700
+    },
+    "\u00e1": {
+        sC: [],
+        xMin: 20,
+        xMax: 950,
+        yMin: -145.6,
+        yMax: 894.4,
+        wdth: 950
+    },
+    "b": {
+        sC: [],
+        xMin: 63,
+        xMax: 575,
+        yMin: -14,
+        yMax: 714,
+        wdth: 611
+    },
+    "c": {
+        sC: [],
+        xMin: 35,
+        xMax: 523,
+        yMin: -14,
+        yMax: 531,
+        wdth: 556
+    },
+    "\u00a0": {
+        sC: [],
+        xMin: 31,
+        xMax: 400,
+        yMin: -4,
+        yMax: 644,
+        wdth: 278
+    },
+    " ": {
+        sC: [],
+        xMin: 31,
+        xMax: 400,
+        yMin: -4,
+        yMax: 644,
+        wdth: 278
+    }
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+    "name": "meshwriter-cudu",
+    "version": "3.0.0",
+    "description": "Modern 3D text rendering for Babylon.js with variable font weights and accessibility features",
+    "type": "module",
+    "main": "./dist/meshwriter.cjs.js",
+    "module": "./dist/meshwriter.esm.js",
+    "types": "./src/types.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/meshwriter.esm.js",
+            "require": "./dist/meshwriter.cjs.js",
+            "types": "./src/types.d.ts"
+        },
+        "./fonts/*": "./fonts/*.js",
+        "./fonts": "./fonts/index.js"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build:rollup": "rollup -c",
+        "build:types": "tsc",
+        "build": "npm run build:rollup && npm run build:types",
+        "typecheck": "tsc --noEmit",
+        "dev": "rollup -c -w",
+        "bake:fonts": "node scripts/bake-fonts.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/cududa/meshwriter-cudu"
+    },
+    "keywords": [
+        "babylonjs",
+        "babylon",
+        "meshwriter",
+        "3d-text",
+        "webgl",
+        "accessibility",
+        "dyslexia",
+        "variable-font",
+        "typescript",
+        "esm"
+    ],
+    "authors": ["Brian T Button","Cullen Dudas"],
+    "license": "MIT",
+    "peerDependencies": {
+        "@babylonjs/core": ">=6.0.0",
+        "earcut": ">=2.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@babylonjs/core": {
+            "optional": false
+        },
+        "earcut": {
+            "optional": false
+        }
+    },
+    "devDependencies": {
+        "@babylonjs/core": "^8.0.0",
+        "@rollup/plugin-commonjs": "^28.0.0",
+        "@rollup/plugin-node-resolve": "^16.0.0",
+        "@rollup/plugin-terser": "^0.4.0",
+        "earcut": "^3.0.2",
+        "fontkit": "^2.0.4",
+        "rollup": "^4.0.0",
+        "typescript": "^5.0.0"
+    },
+    "files": [
+        "dist",
+        "fonts",
+        "src"
+    ],
+    "bugs": {
+        "url": "https://github.com/cududa/meshwriter-cudu/issues"
+    },
+    "homepage": "https://github.com/cududa/meshwriter-cudu#readme"
+}

package/src/babylonImports.js

@@ -0,0 +1,29 @@
+/**
+ * MeshWriter Babylon.js Imports
+ * Centralized imports from @babylonjs/core for tree-shaking
+ */
+
+// Core math types
+export { Vector2, Vector3 } from '@babylonjs/core/Maths/math.vector';
+export { Color3 } from '@babylonjs/core/Maths/math.color';
+export { Path2, Curve3 } from '@babylonjs/core/Maths/math.path';
+
+// Mesh types
+export { Mesh } from '@babylonjs/core/Meshes/mesh';
+export { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
+export { PolygonMeshBuilder } from '@babylonjs/core/Meshes/polygonMesh';
+
+// Materials
+export { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+export { MaterialPluginBase } from '@babylonjs/core/Materials/materialPluginBase';
+
+// Particle system
+export { SolidParticleSystem } from '@babylonjs/core/Particles/solidParticleSystem';
+
+// CSG - legacy (Babylon < 7.31)
+export { CSG } from '@babylonjs/core/Meshes/csg';
+
+// CSG2 - modern (Babylon 7.31+)
+// Import directly - will be available in Babylon 7.31+
+// For older versions, these will be undefined but that's handled in csg.js
+export { CSG2, InitializeCSG2Async, IsCSG2Ready } from '@babylonjs/core/Meshes/csg2';

package/src/bakedFontLoader.js

@@ -0,0 +1,125 @@
+/**
+ * MeshWriter Baked Font Loader
+ * Loads pre-baked FontSpec JSON files at runtime.
+ * Zero dependencies - just fetch and use.
+ */
+
+/**
+ * Load a pre-baked font from a JSON file
+ * @param {string} url - URL to the baked FontSpec JSON file
+ * @returns {Promise<object>} - FontSpec object ready for use with MeshWriter
+ *
+ * @example
+ * const fontSpec = await loadBakedFont('/fonts/baked/atkinson-hyperlegible-next-400.json');
+ * registerFont('Atkinson400', fontSpec);
+ */
+export async function loadBakedFont(url) {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+        throw new Error(`MeshWriter: Failed to load baked font from ${url} (HTTP ${response.status})`);
+    }
+
+    const fontSpec = await response.json();
+
+    // Validate it looks like a FontSpec
+    if (typeof fontSpec !== 'object' || fontSpec === null) {
+        throw new Error(`MeshWriter: Invalid baked font data from ${url}`);
+    }
+
+    return fontSpec;
+}
+
+/**
+ * Load multiple pre-baked weights from a manifest
+ * @param {string} manifestUrl - URL to the manifest.json file
+ * @param {number[]} [weights] - Specific weights to load (loads all if omitted)
+ * @returns {Promise<Map<number, object>>} - Map of weight -> FontSpec
+ *
+ * @example
+ * const fonts = await loadBakedFontsFromManifest('/fonts/baked/manifest.json', [400, 450]);
+ * const fontSpec = fonts.get(400);
+ */
+export async function loadBakedFontsFromManifest(manifestUrl, weights) {
+    const response = await fetch(manifestUrl);
+
+    if (!response.ok) {
+        throw new Error(`MeshWriter: Failed to load manifest from ${manifestUrl} (HTTP ${response.status})`);
+    }
+
+    const manifest = await response.json();
+    const baseUrl = manifestUrl.substring(0, manifestUrl.lastIndexOf('/') + 1);
+
+    // Determine which weights to load
+    const weightsToLoad = weights
+        ? weights.filter(w => manifest.weights.includes(w))
+        : manifest.weights;
+
+    if (weights && weightsToLoad.length !== weights.length) {
+        const missing = weights.filter(w => !manifest.weights.includes(w));
+        console.warn(`MeshWriter: Requested weights not available: ${missing.join(', ')}`);
+        console.warn(`MeshWriter: Available weights: ${manifest.weights.join(', ')}`);
+    }
+
+    // Load all requested weights in parallel
+    const results = await Promise.all(
+        weightsToLoad.map(async (weight) => {
+            const idx = manifest.weights.indexOf(weight);
+            const file = manifest.files[idx];
+            const fontSpec = await loadBakedFont(baseUrl + file);
+            return { weight, fontSpec };
+        })
+    );
+
+    // Build map
+    const fontMap = new Map();
+    for (const { weight, fontSpec } of results) {
+        fontMap.set(weight, fontSpec);
+    }
+
+    return fontMap;
+}
+
+/**
+ * Find the nearest available weight from a set of baked weights
+ * @param {number} targetWeight - Desired weight
+ * @param {number[]} availableWeights - Array of available weights
+ * @returns {number} - Nearest available weight
+ *
+ * @example
+ * const nearest = findNearestWeight(425, [400, 450, 500]);
+ * // Returns 450 (closest to 425)
+ */
+export function findNearestWeight(targetWeight, availableWeights) {
+    if (!availableWeights || availableWeights.length === 0) {
+        throw new Error('MeshWriter: No available weights provided');
+    }
+
+    let nearest = availableWeights[0];
+    let minDiff = Math.abs(targetWeight - nearest);
+
+    for (const weight of availableWeights) {
+        const diff = Math.abs(targetWeight - weight);
+        if (diff < minDiff) {
+            minDiff = diff;
+            nearest = weight;
+        }
+    }
+
+    return nearest;
+}
+
+/**
+ * Get manifest info without loading fonts
+ * @param {string} manifestUrl - URL to the manifest.json file
+ * @returns {Promise<object>} - Manifest object with fontName, weights, etc.
+ */
+export async function getBakedFontManifest(manifestUrl) {
+    const response = await fetch(manifestUrl);
+
+    if (!response.ok) {
+        throw new Error(`MeshWriter: Failed to load manifest from ${manifestUrl} (HTTP ${response.status})`);
+    }
+
+    return response.json();
+}