@mlightcad/mtext-renderer 0.13.3 → 0.13.5

package/lib/font/baseTextShape.d.ts

@@ -14,6 +14,11 @@ export declare abstract class BaseTextShape extends THREE.Shape {
      * @returns A THREE.js BufferGeometry representing the text shape
      */
     abstract toGeometry(): THREE.BufferGeometry;
+    /**
+     * Converts the text shape to line-segment geometry (no filled triangulation).
+     * Mesh fonts sample glyph contours; SHX fonts reuse {@link toGeometry}.
+     */
+    toStrokeGeometry(): THREE.BufferGeometry;
     /**
      * Uniform XY scale applied to {@link toGeometry} when placing the glyph.
      *

package/lib/font/charGeometryCache.d.ts

@@ -16,7 +16,7 @@ export declare class CharGeometryCache {
      * @returns True if the geometry of the specified character code exists in the cache.
      * Otherwise, returns false.
      */
-    hasGeometry(code: number, size: number): boolean;
+    hasGeometry(code: number, size: number, variant?: string): boolean;
     /**
      * Get the geometry for a single character from cache if available.
      * The cache key includes both character codeand size.
@@ -25,14 +25,14 @@ export declare class CharGeometryCache {
      * @returns The geometry for a single character from cache if avaiable.
      * Return undefined if the character not found in cache.
      */
-    getGeometry(code: number, size: number): THREE.BufferGeometry | undefined;
+    getGeometry(code: number, size: number, variant?: string): THREE.BufferGeometry | undefined;
     /**
      * Set the geometry to cache for a single character.
      * @param char The character to set geometry for.
      * @param size The font size.
      * @param geometry The geometry to set.
      */
-    setGeometry(code: number, size: number, geometry: THREE.BufferGeometry): void;
+    setGeometry(code: number, size: number, geometry: THREE.BufferGeometry, variant?: string): void;
     /**
      * Estimates memory used by cached BufferGeometry attribute/index buffers.
      */

package/lib/font/meshFont.d.ts

@@ -122,6 +122,13 @@ export declare class MeshFont extends BaseFont {
      * @returns Array of shapes representing the text
      */
     generateShapes(text: string, size: number): import('three').Shape[];
+    /**
+     * Generates line-segment geometry for a text string (glyph contours only).
+     * @param text - The text to generate strokes for
+     * @param size - The size of the text
+     * @returns Indexed line-pair BufferGeometry suitable for LineSegments
+     */
+    generateStrokeGeometry(text: string, size: number): import('three').BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>;
     /**
      * Gets the shape data for a specific character at a given size.
      * @param char - The character to get the shape for

package/lib/font/meshGlyphGeometry.d.ts

@@ -12,6 +12,16 @@ export declare const MESH_GLYPH_USER_DATA_KEY = "isMeshGlyph";
  * Placement scales by {@link MeshTextShape.geometryScale} (= requested size).
  */
 export declare const MESH_GLYPH_CACHE_SIZE = 1;
+/**
+ * {@link CharGeometryCache} variant for contour line-segment glyphs.
+ * Fill geometry uses the default `'fill'` variant so the two caches do not collide.
+ */
+export declare const MESH_GLYPH_STROKE_CACHE_VARIANT = "stroke";
+/**
+ * Curve samples per path segment when triangulating or stroking mesh glyphs.
+ * Matches {@link THREE.ShapeGeometry}’s `curveSegments` argument.
+ */
+export declare const MESH_GLYPH_CURVE_SEGMENTS = 4;
 /**
  * Returns true when `geometry` is a mesh-font glyph (filled outline),
  * including geometries baked down to a plain {@link THREE.BufferGeometry}.

package/lib/font/meshTextShape.d.ts

@@ -27,6 +27,11 @@ export declare class MeshTextShape extends BaseTextShape {
      * @returns A THREE.js BufferGeometry representing the text shape
      */
     toGeometry(): THREE.BufferGeometry;
+    /**
+     * Samples glyph contours into line segments without triangulating.
+     * Cached separately from {@link toGeometry} at {@link MESH_GLYPH_CACHE_SIZE}.
+     */
+    toStrokeGeometry(): THREE.BufferGeometry;
     /** @inheritdoc */
     hasStrokeGeometry(): boolean;
     /**

package/lib/font/shxFont.d.ts

@@ -51,8 +51,20 @@ export declare class ShxFont extends BaseFont {
      */
     generateShapes(text: string, size: number): ShxTextShape[];
     /**
-     * Returns the scale factor used by the SHX font implementation.
-     * @returns Always returns 1 for SHX fonts.
+     * Scale factor that converts AutoCAD's `TEXT.height` (cap-height) into the
+     * em-box size expected by {@link getCharShape} / `shx-parser`.
+     *
+     * SHX glyphs are defined with `baseUp` units of cap-height and `height` units
+     * of total em-box (`baseUp + baseDown`). AutoCAD's DXF group 40 is the
+     * cap-height, so the correct scale is `size / baseUp`. The parser still
+     * divides by `content.height`; returning `height / baseUp` here makes the
+     * effective scale `size / baseUp` (cad-viewer#724).
+     *
+     * Validated against Autodesk stock metrics: `gbenor` 60/48, `tssdeng` 33/26,
+     * `romans`/`complex` 28/21. Extended BIGFONT faces often set `baseUp == height`,
+     * so the factor stays `1` and CJK cell size is unchanged.
+     *
+     * @returns `height / baseUp` when both are positive; otherwise `1`.
      */
     getScaleFactor(): number;
     /**

package/lib/font/shxLayoutAdvance.d.ts

@@ -17,5 +17,19 @@ export declare class ShxPenAdvanceStrategy extends ShxAdvanceWidthStrategy {
     /** Store the resolved advance so a later default-strategy pass does not recompute it. */
     markAlignedAdvanceExplicit(_shape: ShxShape): boolean;
 }
+/**
+ * Horizontal advance for BIGFONT (CJK) glyphs.
+ *
+ * AutoCAD advances double-byte BIGFONT text by the font cell width. Falling back
+ * to ink width (as western SHX sometimes needs) shifts wrap points and drifts
+ * mixed Latin/CJK runs (cad-viewer#724). Prefer the pen when the shape encodes
+ * an explicit advance; otherwise use the full cell.
+ */
+export declare class ShxBigfontAdvanceStrategy extends ShxAdvanceWidthStrategy {
+    resolve(shape: ShxShape, cellWidth: number): number;
+    markAlignedAdvanceExplicit(_shape: ShxShape): boolean;
+}
 /** Shared strategy passed to `ShxFont.getLayoutCharShape` and {@link resolveAdvanceWidth}. */
 export declare const shxPenAdvanceStrategy: ShxPenAdvanceStrategy;
+/** Shared BIGFONT strategy — cell width instead of ink-width fallback. */
+export declare const shxBigfontAdvanceStrategy: ShxBigfontAdvanceStrategy;

package/lib/font/shxTextShape.d.ts

@@ -38,7 +38,7 @@ export declare class ShxTextShape extends BaseTextShape {
      * Converts the text shape to a THREE.js geometry.
      * @returns A BufferGeometry representing the text shape.
      */
-    toGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+    toGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
     /** @inheritdoc */
     hasStrokeGeometry(): boolean;
     /**

package/lib/font/threeFont.d.ts

@@ -1,50 +1,27 @@
-import { Shape } from 'three';
+import { BufferGeometry } from 'three';
 import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
 type Direction = 'ltr' | 'rtl' | 'tb';
 /**
- * Extended Font that fixes inner holes for problematic fonts like SimSun.
- * Certain characters have incorrect inner contours (holes), e.g., 面, 限, 用, 色, 8.
+ * Font used for mesh glyphs.
+ *
+ * Filled outlines come from {@link Font.generateShapes}, which delegates to
+ * `ShapePath.toShapes()`. That path correctly classifies holes for fonts such
+ * as SimSun (面, 限, 用, 色, 8) starting with three.js r185 (0.185.1).
+ *
+ * Stroke geometry is still built here: it only needs sampled contours, not
+ * hole classification.
  */
 export declare class ThreeFont extends Font {
     /**
-     * Generates geometry shapes from the given text and size.
+     * Samples glyph contours into line-segment geometry without hole detection
+     * or triangulation.
      *
-     * Algorithm overview:
-     * 1. Split the input text into individual characters.
-     * 2. For each character:
-     *    a. Retrieve the glyph data from the font.
-     *    b. Convert the glyph outline commands into a ShapePath.
-     *       - 'm' → moveTo
-     *       - 'l' → lineTo
-     *       - 'q' → quadraticCurveTo
-     *       - 'b' → cubic bezierCurveTo
-     *    c. Apply scaling to match the requested font size.
-     *    d. Apply offsets for proper placement (supports multiple lines and directions).
-     * 3. Handle text direction:
-     *    - 'ltr': left-to-right
-     *    - 'rtl': right-to-left (characters reversed)
-     *    - 'tb': top-to-bottom (vertical layout)
-     * 4. Collect all ShapePaths for the text.
-     * 5. Convert each ShapePath into one or more Shape objects:
-     *    a. Sample points along each subPath to approximate geometry.
-     *    b. Determine which subPaths are outer contours and which are holes:
-     *       - For each subPath, check if it is fully contained inside another polygon.
-     *       - Assign the smallest containing polygon as its parent.
-     *    c. Compute the relative depth of each subPath to handle nested holes.
-     *    d. Reverse curves if necessary to maintain correct clockwise/counterclockwise winding:
-     *       - Outer contours: CCW
-     *       - Holes: CW
-     *    e. Build Shape objects with holes properly assigned.
-     * 6. Return the final array of Shape objects ready for geometry creation.
-     *
-     * This algorithm ensures that complex characters with multiple independent contours
-     * (including intersecting subpaths or holes) are rendered correctly.
-     *
-     * @param text - input string to convert to shapes
+     * @param text - input string to convert to strokes
      * @param size - font size in units (default 100)
      * @param direction - text direction ('ltr', 'rtl', 'tb')
-     * @returns array of Shape objects with proper holes and contours
+     * @param curveSegments - samples per curve (same meaning as ShapeGeometry)
+     * @returns a BufferGeometry of indexed line pairs suitable for LineSegments
      */
-    generateShapes(text: string, size?: number, direction?: Direction): Shape[];
+    generateStrokeGeometry(text: string, size?: number, direction?: Direction, curveSegments?: number): BufferGeometry;
 }
 export {};

package/lib/renderer/mtextProcessor.d.ts

@@ -1,7 +1,7 @@
 import { ChangedProperties, MTextParagraphAlignment, MTextToken } from '@mlightcad/mtext-parser';
 import { FontManager } from '../font';
 import { StyleManager } from './styleManager';
-import { ColorSettings, LineLayout, MTextFlowDirection, MTextLineSpacingStyle, TextStyle } from './types';
+import { ColorSettings, LineLayout, MeshFontRenderMode, MTextFlowDirection, MTextLineSpacingStyle, TextStyle } from './types';
 import * as THREE from 'three';
 /**
  * Options for formatting MText.
@@ -53,6 +53,10 @@ export interface MTextFormatOptions {
      * Whether to collect per-character bounding boxes for picking.
      */
     collectCharBoxes?: boolean;
+    /**
+     * How TrueType/OTF (mesh) glyphs are drawn. Default is `'mesh'`.
+     */
+    meshFontRenderMode?: MeshFontRenderMode;
 }
 /**
  * Converts parsed MText tokens into positioned THREE.js geometry.
@@ -131,8 +135,9 @@ export declare class MTextProcessor {
     private _currentRightMargin;
     /**
      * When true, {@link processChar} will not soft-wrap even if the pen is past the
-     * defined width. Used while finishing a short word that AutoCAD keeps on the
-     * current line with a slight overhang.
+     * defined width. Used for Latin/ASCII word tokens (AutoCAD does not hyphenate
+     * them) and for a short Latin run that AutoCAD keeps on the current line with
+     * a slight overhang after CJK.
      */
     private _suppressSoftWrap;
     /**
@@ -367,12 +372,12 @@ export declare class MTextProcessor {
      */
     private applyParagraphChange;
     /**
-     * Reset paragraph properties to their default values from options.
-     */
-    private resetParagraphProperties;
-    /**
-     * Start a new paragraph by processing current geometries, resetting paragraph properties,
-     * and starting a new line with indent applied.
+     * Start a new paragraph by flushing the current line and applying the
+     * persisted first-line indent.
+     *
+     * AutoCAD keeps `\p` paragraph properties (alignment, indent, margins)
+     * until the next `\p` command. `\P` only ends the current paragraph.
+     *
      * @param geometries Current text geometries to process
      * @param lineGeometries Current line geometries to process
      * @param meshCharBoxes Mesh char boxes to flush with the current line
@@ -405,6 +410,11 @@ export declare class MTextProcessor {
      * @returns Horizontal advance width after width factor and oblique skew.
      */
     private buildShapeGeometry;
+    /**
+     * Filled mesh glyphs or sampled contour strokes, depending on
+     * {@link MTextFormatOptions.meshFontRenderMode}.
+     */
+    private getGlyphGeometry;
     /**
      * Builds the world transform for one glyph (width factor, oblique, bold, translate).
      *
@@ -472,9 +482,11 @@ export declare class MTextProcessor {
      *
      * - CJK / non-Latin: no whole-word wrap — {@link processChar} breaks between
      *   characters when the next glyph would not fit in the defined width.
-     * - Latin/ASCII: keep Western word wrapping, except a short run that only
-     *   slightly overshoots after CJK (e.g. `秘密-FJP-898E-G`) may stay on the
-     *   current line with a small overhang (AutoCAD).
+     * - Latin/ASCII: wrap only at word boundaries (spaces). AutoCAD/GstarCAD do
+     *   not hyphenate: a token wider than the column stays on one visual line and
+     *   overflows the box (e.g. part numbers like `1157*25*1.5`). A short run that
+     *   only slightly overshoots after CJK (e.g. `秘密-FJP-898E-G`) may stay on
+     *   the current line with a small overhang.
      *
      * @param word Character sequence for a single word token.
      * @param geometries Mesh geometry accumulator for the active style segment.
@@ -545,7 +557,8 @@ export declare class MTextProcessor {
      *
      * Missing glyphs are treated as spaces. Soft wrap is decided before placement:
      * if the glyph's advance would not fit in the remaining defined width, break
-     * first (CJK may break between any two characters). The first glyph on an
+     * first (CJK may break between any two characters). Latin/ASCII word tokens
+     * suppress this so they overflow instead of hyphenating. The first glyph on an
      * empty line is always placed even when wider than the box.
      *
      * @param char Character to render.
@@ -584,6 +597,13 @@ export declare class MTextProcessor {
      * @returns `true` when the shape should be drawn instead of replaced with the not-found glyph.
      */
     private shapeHasStrokeGeometry;
+    /**
+     * Tries GDT / symbol SHX fonts for a percent-control-code symbol.
+     *
+     * @param data Parser percent-symbol payload.
+     * @returns A symbol-font shape when one is available; otherwise `undefined`.
+     */
+    private trySymbolFontPercentShape;
     /**
      * Resolves the best available shape for a percent-control-code symbol.
      *

package/lib/renderer/shxSymbolControlCodes.d.ts

@@ -19,3 +19,11 @@ export declare const AUTOCAD_PERCENT_SYMBOL_CONTROL_CODES: Readonly<Record<AutoC
  * Returns ordered font code points to try for a parser-emitted percent symbol.
  */
 export declare function getPercentSymbolLookupCodes(data: PercentSymbolData): readonly number[];
+/**
+ * Maps a literal Unicode dimension symbol to a named AutoCAD percent-symbol
+ * token when converters have already expanded `%%c` / `%%d` / `%%p`.
+ *
+ * @returns Named percent-symbol data, or `undefined` when `char` is not a
+ *   known dimension-symbol substitute.
+ */
+export declare function getLiteralPercentSymbolData(char: string): PercentSymbolData | undefined;

package/lib/renderer/types.d.ts

@@ -165,6 +165,12 @@ export interface ColorSettings {
  * Create default color settings (ByLayer + white fallback).
  */
 export declare const createDefaultColorSettings: () => ColorSettings;
+/**
+ * How TrueType/OTF (mesh) glyphs are converted to drawable geometry.
+ * - `mesh`: triangulate filled outlines (default)
+ * - `line`: sample glyph contours as line segments (no triangulation)
+ */
+export type MeshFontRenderMode = 'mesh' | 'line';
 /**
  * Represents the data structure for multiline text (MText) entities.
  * Contains all necessary properties to define the appearance and positioning of text.
@@ -201,6 +207,12 @@ export interface MTextData {
     widthFactor?: number;
     /** Whether to collect per-character bounding boxes for picking. Default is true */
     collectCharBoxes?: boolean;
+    /**
+     * How TrueType/OTF (mesh) glyphs are drawn.
+     * `mesh` triangulates filled outlines (default).
+     * `line` draws sampled contours only, skipping triangulation.
+     */
+    meshFontRenderMode?: MeshFontRenderMode;
 }
 /**
  * Describes one AutoCAD SHAPE entity for rendering.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlightcad/mtext-renderer",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "description": "AutoCAD MText renderer based on Three.js",
   "license": "MIT",
   "author": "MLight Lee <mlight.lee@outlook.com>",
@@ -49,14 +49,15 @@
     "opentype.js": "^2.0.0"
   },
   "devDependencies": {
-    "@mlightcad/mtext-parser": "^1.5.3",
+    "@mlightcad/mtext-parser": "^1.5.5",
     "@types/opentype.js": "^1.3.10",
-    "@types/three": "^0.172.0",
+    "@types/three": "^0.186.0",
+    "three": "^0.186.1",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@mlightcad/mtext-parser": "^1.5.3",
-    "three": "^0.172.0"
+    "@mlightcad/mtext-parser": "^1.5.5",
+    "three": ">=0.185.1"
   },
   "scripts": {
     "build": "tsc && vite build -c vite.config.main.ts && vite build -c vite.config.worker.ts",