@mlightcad/mtext-renderer 0.10.14 → 0.10.15

package/dist/mtext-renderer-worker.js

@@ -28418,8 +28418,25 @@ var P1 = Fc((L) => {
      * @param shape - The shape data for this character
      */
     constructor(e, t, r, i) {
-      var s;
-      super(), this.fontSize = t, this.shape = r, this.font = i, this.code = e, i.data.header.fontType === Te.BIGFONT ? this.width = this.calcWidth() : this.width = ((s = r.lastPoint) == null ? void 0 : s.x) ?? this.calcWidth();
+      super(), this.fontSize = t, this.shape = r, this.font = i, this.code = e, this.width = this.resolveAdvanceWidth(r);
+    }
+    /**
+     * Resolves horizontal advance for SHX glyphs.
+     *
+     * - Unicode / shapes fonts: prefer the pen-down end X (lastPoint), which matches
+     *   AutoCAD's advance for single-byte SHX.
+     * - Big fonts (CJK): advance is the scaled font cell width (content.width /
+     *   content.height * fontSize). Glyph bbox or lastPoint can be narrower than the
+     *   cell; using only bbox caused successive Han characters to overlap visually.
+     */
+    resolveAdvanceWidth(e) {
+      var i;
+      const t = this.calcWidth(), r = ((i = e.lastPoint) == null ? void 0 : i.x) ?? 0;
+      if (this.font.data.header.fontType === Te.BIGFONT) {
+        const { width: s, height: a } = this.font.data.content, o = a > 0 ? s / a * this.fontSize : 0;
+        return Math.max(t, r, o);
+      }
+      return r > 0 ? r : t;
     }
     calcWidth() {
       const e = this.shape.bbox;
@@ -28479,18 +28496,27 @@ var P1 = Fc((L) => {
     hasCode(e) {
       return this.font.hasChar(e);
     }
+    /**
+     * Horizontal advance for the space character (ASCII 32) at the given size.
+     * Uses the SHX glyph pen advance when defined; otherwise falls back to half the
+     * text height (common for AutoCAD SHX fonts).
+     */
+    getSpaceAdvance(e) {
+      const t = this.getCharShape(" ", e);
+      return t ? t.width : e * 0.5;
+    }
     generateShapes(e, t) {
       const r = [];
       let i = 0;
       for (let s = 0; s < e.length; s++) {
         const a = e[s];
         if (a === " ") {
-          i += t;
+          i += this.getSpaceAdvance(t);
           continue;
         }
         const o = this.getCharShape(a, t);
         if (!o) {
-          i += t, this.addUnsupportedChar(a);
+          i += this.getSpaceAdvance(t), this.addUnsupportedChar(a);
           continue;
         }
         r.push(o.offset(new fe(i, 0))), i += o.width;
@@ -28498,11 +28524,35 @@ var P1 = Fc((L) => {
       return r;
     }
     /**
-     * SHX font always has fixed scale factor 1.
-     * @returns Always return value 1
+     * Scale factor that converts AutoCAD's `TEXT.height` (cap-height in the SHX
+     * convention) into the em-box-scaled size expected by `generateShapes`.
+     *
+     * SHX glyphs are defined with `baseUp` units of cap-height (height of an
+     * uppercase letter above the baseline) and `height` units of total em-box
+     * (cap-height + descender + headroom for accents). AutoCAD's DXF group 40
+     * for TEXT/ATTRIB/MTEXT is the cap-height — the historical SHX convention
+     * since the format's introduction in AutoCAD R2 (1985), kept by AutoCAD
+     * when TrueType support was added in the early 1990s so that DWGs portable
+     * across font formats render at consistent visual sizes.
+     *
+     * Returning `1` (the previous behavior) meant SHX glyphs were rendered at
+     * `baseUp / height` of the expected size — typically ~0.75 for western
+     * fonts like `romans.shx`/`complex.shx` where `baseUp=21, height=28`.
+     * Multiplying by `height / baseUp` restores the cap-height interpretation.
+     *
+     * Mirrors the behavior already in place for mesh fonts (see
+     * `meshFontParser.ts` where `scaleFactor = unitsPerEm / glyph('A').yMax`),
+     * isolated to the glyph render path only — `mtextProcessor.currentLayoutFontSize`
+     * divides by this factor to keep layout metrics (line height, attachment
+     * offsets, blank width) on the original cap-height scale.
+     *
+     * @returns `height / baseUp` when both are populated and positive; `1`
+     *   otherwise (e.g. exotic BIGFONT/symbol fonts without standard metrics),
+     *   matching the prior behavior as a safe fallback.
      */
     getScaleFactor() {
-      return 1;
+      const { height: e, baseUp: t } = this.data.content;
+      return t > 0 && e > 0 ? e / t : 1;
     }
     /**
      * Gets the shape data for a specific character at a given size.
@@ -29203,6 +29253,10 @@ var P1 = Fc((L) => {
     get currentWidthFactor() {
       return this._currentContext.widthFactor.value;
     }
+    /** Horizontal advance for one space, including tracking and width factor. */
+    get currentBlankAdvance() {
+      return this._currentContext.blankWidth * this.currentWordSpace * this.currentWidthFactor;
+    }
     /**
      * All of THREE.js objects in current line. It contains objects in all of sections of this line.
      */
@@ -29535,7 +29589,7 @@ var P1 = Fc((L) => {
       let a = 0;
       for (let o = 0; o < e.length; o++) {
         const h = this.getCharShape(e[o]);
-        h ? this.currentHorizontalAlignment == ce.DISTRIBUTED ? a += h.width * this.currentWidthFactor : a += h.width * this.currentWordSpace * this.currentWidthFactor : a += this._currentContext.blankWidth;
+        h ? this.currentHorizontalAlignment == ce.DISTRIBUTED ? a += h.width * this.currentWidthFactor : a += h.width * this.currentWordSpace * this.currentWidthFactor : a += this.currentBlankAdvance;
       }
       this.hOffset + a > (this.maxLineWidth || 1 / 0) && (this._vOffset <= 0 && this._currentLineObjects.length <= 0 || (this.recordVisualLineBreak(i, s), this.advanceToNextLine(!1)));
       for (let o = 0; o < e.length; o++)
@@ -29680,7 +29734,7 @@ var P1 = Fc((L) => {
         const r = this._hOffset, i = this.flowDirection == Mt.BOTTOM_TO_TOP ? this._vOffset : this._vOffset - this.currentLayoutFontSize, s = new ke(
           new E(r, i, 0),
           new E(
-            r + this._currentContext.blankWidth,
+            r + this.currentBlankAdvance,
             i + this.currentLayoutFontSize,
             0
           )
@@ -29697,7 +29751,7 @@ var P1 = Fc((L) => {
           children: []
         });
       }
-      this._hOffset += this._currentContext.blankWidth;
+      this._hOffset += this.currentBlankAdvance;
     }
     recordVisualLineBreak(e, t) {
       const r = this._processedCharCount + this.countFinalCharBoxes(
@@ -29723,12 +29777,15 @@ var P1 = Fc((L) => {
       this._lineHasRenderableChar || this.applyPendingEmptyLineYAdjust();
       const o = a.toGeometry();
       o.scale(this.currentWidthFactor, 1, 1);
-      let h = this._currentContext.oblique;
-      if (this._currentContext.italic && (h += 15), h) {
-        const x = h * Math.PI / 180, v = new Fe();
-        v.set(
+      const h = this.currentLayoutFontSize;
+      let c = this._currentContext.oblique;
+      this._currentContext.italic && (c += 15);
+      let u = 0;
+      if (c) {
+        const w = c * Math.PI / 180, b = new Fe();
+        b.set(
           1,
-          Math.tan(x),
+          Math.tan(w),
           0,
           0,
           0,
@@ -29743,77 +29800,79 @@ var P1 = Fc((L) => {
           0,
           0,
           1
-        ), o.applyMatrix4(v);
-      }
-      const c = this.fontManager.getFontType(this.currentFont);
-      this._currentContext.bold && c === "mesh" && o.scale(1.06, 1.06, 1), this.hOffset > (this.maxLineWidth || 1 / 0) && (this.recordVisualLineBreak(i, s), this.advanceToNextLine(!1));
-      const u = this.hOffset, f = this.flowDirection == Mt.BOTTOM_TO_TOP ? this.vOffset : this.vOffset - this.currentLayoutFontSize, l = a.width * this.currentWidthFactor, p = this.currentLayoutFontSize;
-      if (o.translate(u, f, 0), this.currentHorizontalAlignment == ce.DISTRIBUTED ? this._hOffset += a.width * this.currentWidthFactor : this._hOffset += a.width * this.currentWordSpace * this.currentWidthFactor, t.push(o), this._lineHasRenderableChar = !0, this._options.collectCharBoxes !== !1) {
+        ), o.applyMatrix4(b), u = Math.tan(w) * h;
+      }
+      const f = this.fontManager.getFontType(this.currentFont);
+      this._currentContext.bold && f === "mesh" && o.scale(1.06, 1.06, 1), this.hOffset > (this.maxLineWidth || 1 / 0) && (this.recordVisualLineBreak(i, s), this.advanceToNextLine(!1));
+      const l = this.hOffset, p = this.flowDirection == Mt.BOTTOM_TO_TOP ? this.vOffset : this.vOffset - this.currentLayoutFontSize, d = a.width * this.currentWidthFactor;
+      o.translate(l, p, 0);
+      const m = a.width * this.currentWidthFactor + u * this.currentWidthFactor;
+      if (this.currentHorizontalAlignment == ce.DISTRIBUTED ? this._hOffset += m : this._hOffset += a.width * this.currentWordSpace * this.currentWidthFactor + u * this.currentWidthFactor, t.push(o), this._lineHasRenderableChar = !0, this._options.collectCharBoxes !== !1) {
         o.userData.char = e, o.boundingBox || o.computeBoundingBox();
-        const x = new ke().copy(o.boundingBox);
+        const w = new ke().copy(o.boundingBox);
         o instanceof mr ? (this._lastCharBoxTarget = "mesh", i.push({
           type: ye.CHAR,
-          box: x,
+          box: w,
           char: e,
           children: []
         })) : (this._lastCharBoxTarget = "line", s.push({
           type: ye.CHAR,
-          box: x,
+          box: w,
           char: e,
           children: []
         }));
       }
-      const d = p * 0.05, m = 1e-3;
+      const x = h * 0.05, v = 1e-3;
       if (this._currentContext.underline) {
-        const x = new ze(), v = f - d;
-        x.setAttribute(
+        const w = new ze(), b = p - x;
+        w.setAttribute(
           "position",
           new Ye(
             new Float32Array([
-              u,
-              v,
-              m,
-              u + l,
+              l,
+              b,
               v,
-              m
+              l + d,
+              b,
+              v
             ]),
             3
           )
-        ), x.setIndex(null), x.userData = { isDecoration: !0 }, r.push(x);
+        ), w.setIndex(null), w.userData = { isDecoration: !0 }, r.push(w);
       }
       if (this._currentContext.overline) {
-        const x = new ze(), v = f + p + d;
-        x.setAttribute(
+        const w = new ze(), b = p + h + x;
+        w.setAttribute(
           "position",
           new Ye(
             new Float32Array([
-              u,
-              v,
-              m,
-              u + l,
+              l,
+              b,
               v,
-              m
+              l + d,
+              b,
+              v
             ]),
             3
           )
-        ), x.setIndex(null), x.userData = { isDecoration: !0 }, r.push(x);
+        ), w.setIndex(null), w.userData = { isDecoration: !0 }, r.push(w);
       }
       if (this._currentContext.strikeThrough) {
-        const x = new ze(), v = f + p / 2 - p * 0.2;
-        x.setAttribute(
+        const w = new ze(), b = p + h / 2 - h * 0.2;
+        w.setAttribute(
           "position",
           new Ye(
             new Float32Array([
-              u,
-              v,
-              m,
-              u + l,
+              l,
+              b,
               v,
-              m
+              l + d,
+              b,
+              v
             ]),
             3
           )
-        ), x.setIndex(null), x.userData = { isDecoration: !0 }, r.push(x);
+        ), w.setIndex(null), w.userData = { isDecoration: !0 }, r.push(w);
       }
     }
     processLastLine() {
@@ -29946,17 +30005,15 @@ var P1 = Fc((L) => {
       }
     }
     /**
-     * In AutoCAD, the width of a regular space character (ASCII 32, the space key on the keyboard) in MText
-     * depends on the current font and text height, and is not a fixed value.
-     * Specifically:
-     * - Space width ≈ Text height × space width ratio defined by the font
-     * - For common TrueType fonts (like Arial), the space width is typically about 1/4 to 1/3 of the text height.
-     * For example, if the text height is 10 (units), the space width would be approximately 2.5 to 3.3 units.
-     * - For SHX fonts (AutoCAD's built-in vector fonts, such as txt.shx), the space width is often half the text height.
-     * So if the text height is 10, the space width is typically 5 units.
+     * Resolves horizontal advance for an ASCII space in the active font.
+     *
+     * AutoCAD uses each font's own space glyph metrics (SHX pen advance or TrueType
+     * horizontal advance). A fixed fraction of text height (e.g. 50% for SHX) is only
+     * a rough fallback when the font has no space definition.
      */
     calculateBlankWidthForFont(e, t) {
-      return this.fontManager.getFontType(e) === "shx" ? t * 0.5 : t * 0.3;
+      const r = this.fontManager.getCharShape(" ", e, t);
+      return r && r.width > 0 ? r.width : this.fontManager.getFontType(e) === "shx" ? t * 0.5 : t * 0.3;
     }
     /**
      * Convert the text shape geometries to three.js object

package/lib/font/shxFont.d.ts

@@ -24,10 +24,39 @@ export declare class ShxFont extends BaseFont {
      * @returns True if this font contains glyph of the specified character code. Otherwise, return false.
      */
     hasCode(code: number): boolean;
+    /**
+     * Horizontal advance for the space character (ASCII 32) at the given size.
+     * Uses the SHX glyph pen advance when defined; otherwise falls back to half the
+     * text height (common for AutoCAD SHX fonts).
+     */
+    getSpaceAdvance(size: number): number;
     generateShapes(text: string, size: number): ShxTextShape[];
     /**
-     * SHX font always has fixed scale factor 1.
-     * @returns Always return value 1
+     * Scale factor that converts AutoCAD's `TEXT.height` (cap-height in the SHX
+     * convention) into the em-box-scaled size expected by `generateShapes`.
+     *
+     * SHX glyphs are defined with `baseUp` units of cap-height (height of an
+     * uppercase letter above the baseline) and `height` units of total em-box
+     * (cap-height + descender + headroom for accents). AutoCAD's DXF group 40
+     * for TEXT/ATTRIB/MTEXT is the cap-height — the historical SHX convention
+     * since the format's introduction in AutoCAD R2 (1985), kept by AutoCAD
+     * when TrueType support was added in the early 1990s so that DWGs portable
+     * across font formats render at consistent visual sizes.
+     *
+     * Returning `1` (the previous behavior) meant SHX glyphs were rendered at
+     * `baseUp / height` of the expected size — typically ~0.75 for western
+     * fonts like `romans.shx`/`complex.shx` where `baseUp=21, height=28`.
+     * Multiplying by `height / baseUp` restores the cap-height interpretation.
+     *
+     * Mirrors the behavior already in place for mesh fonts (see
+     * `meshFontParser.ts` where `scaleFactor = unitsPerEm / glyph('A').yMax`),
+     * isolated to the glyph render path only — `mtextProcessor.currentLayoutFontSize`
+     * divides by this factor to keep layout metrics (line height, attachment
+     * offsets, blank width) on the original cap-height scale.
+     *
+     * @returns `height / baseUp` when both are populated and positive; `1`
+     *   otherwise (e.g. exotic BIGFONT/symbol fonts without standard metrics),
+     *   matching the prior behavior as a safe fallback.
      */
     getScaleFactor(): number;
     /**

package/lib/font/shxTextShape.d.ts

@@ -19,6 +19,16 @@ export declare class ShxTextShape extends BaseTextShape {
      * @param shape - The shape data for this character
      */
     constructor(code: number, fontSize: number, shape: ShxShape, font: ShxFont);
+    /**
+     * Resolves horizontal advance for SHX glyphs.
+     *
+     * - Unicode / shapes fonts: prefer the pen-down end X (lastPoint), which matches
+     *   AutoCAD's advance for single-byte SHX.
+     * - Big fonts (CJK): advance is the scaled font cell width (content.width /
+     *   content.height * fontSize). Glyph bbox or lastPoint can be narrower than the
+     *   cell; using only bbox caused successive Han characters to overlap visually.
+     */
+    private resolveAdvanceWidth;
     protected calcWidth(): number;
     offset(offset: Point): ShxTextShape;
     /**

package/lib/renderer/mtextProcessor.d.ts

@@ -166,6 +166,8 @@ export declare class MTextProcessor {
      * The current scale factor of character width
      */
     get currentWidthFactor(): number;
+    /** Horizontal advance for one space, including tracking and width factor. */
+    get currentBlankAdvance(): number;
     /**
      * All of THREE.js objects in current line. It contains objects in all of sections of this line.
      */
@@ -305,14 +307,11 @@ export declare class MTextProcessor {
      */
     private processAlignment;
     /**
-     * In AutoCAD, the width of a regular space character (ASCII 32, the space key on the keyboard) in MText
-     * depends on the current font and text height, and is not a fixed value.
-     * Specifically:
-     * - Space width ≈ Text height × space width ratio defined by the font
-     * - For common TrueType fonts (like Arial), the space width is typically about 1/4 to 1/3 of the text height.
-     * For example, if the text height is 10 (units), the space width would be approximately 2.5 to 3.3 units.
-     * - For SHX fonts (AutoCAD's built-in vector fonts, such as txt.shx), the space width is often half the text height.
-     * So if the text height is 10, the space width is typically 5 units.
+     * Resolves horizontal advance for an ASCII space in the active font.
+     *
+     * AutoCAD uses each font's own space glyph metrics (SHX pen advance or TrueType
+     * horizontal advance). A fixed fraction of text height (e.g. 50% for SHX) is only
+     * a rough fallback when the font has no space definition.
      */
     private calculateBlankWidthForFont;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlightcad/mtext-renderer",
-  "version": "0.10.14",
+  "version": "0.10.15",
   "description": "AutoCAD MText renderer based on Three.js",
   "license": "MIT",
   "author": "MLight Lee <mlight.lee@outlook.com>",