@saboit-dev/thomas 1.0.0

package/text_engine_2d/MSDFTextGeometry/TextLayout.js

@@ -0,0 +1,357 @@
+import wordWrap from 'word-wrapper';
+
+// @ts-ignore
+const X_HEIGHTS = ['x', 'e', 'a', 'o', 'n', 's', 'r', 'c', 'u', 'm', 'v', 'w', 'z'];
+const M_WIDTHS = ['m', 'w'];
+const CAP_HEIGHTS = ['H', 'I', 'N', 'E', 'F', 'K', 'L', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
+const TAB_ID = '\t'.charCodeAt(0);
+const SPACE_ID = ' '.charCodeAt(0);
+const ALIGN_LEFT = 0;
+const ALIGN_CENTER = 1;
+const ALIGN_RIGHT = 2;
+class TextLayout {
+  _options = {};
+  _width = 0;
+  _height = 0;
+  _descender = 0;
+  _ascender = 0;
+  _xHeight = 0;
+  _baseline = 0;
+  _capHeight = 0;
+  _lineHeight = 0;
+  _linesTotal = 0;
+  _lettersTotal = 0;
+  _wordsTotal = 0;
+  _fallbackSpaceGlyph = null;
+  _fallbackTabGlyph = null;
+  constructor(text, options = {}) {
+    this.glyphs = [];
+    this._text = text;
+    this._measure = this.computeMetrics.bind(this);
+    this.update(options);
+  }
+
+  /**
+   * Getters
+   */
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get descender() {
+    return this._descender;
+  }
+  get ascender() {
+    return this._ascender;
+  }
+  get xHeight() {
+    return this._xHeight;
+  }
+  get baseline() {
+    return this._baseline;
+  }
+  get capHeight() {
+    return this._capHeight;
+  }
+  get lineHeight() {
+    return this._lineHeight;
+  }
+  get linesTotal() {
+    return this._linesTotal;
+  }
+  get lettersTotal() {
+    return this._lettersTotal;
+  }
+  get wordsTotal() {
+    return this._wordsTotal;
+  }
+  update(options) {
+    options = Object.assign({
+      measure: this._measure
+    }, options);
+    this._options = options;
+    this._options.tabSize = number(this._options.tabSize, 4);
+    if (!options.font) {
+      throw new Error('must provide a valid bitmap font');
+    }
+    const glyphs = this.glyphs;
+    const text = this._text || '';
+    const font = options.font;
+    this._setupSpaceGlyphs(font);
+    const lines = wordWrap.lines(text, options);
+    const minWidth = options.width || 0;
+    const wordsTotal = text.split(' ').filter(word => word !== '\n').length;
+    const lettersTotal = text.split('').filter(char => char !== '\n' && char !== ' ').length;
+
+    // clear glyphs
+    glyphs.length = 0;
+
+    // get max line width
+    const maxLineWidth = lines.reduce(function (prev, line) {
+      return Math.max(prev, line.width, minWidth);
+    }, 0);
+
+    // the pen position
+    let x = 0;
+    let y = 0;
+    const lineHeight = number(options.lineHeight, font.common.lineHeight);
+    const baseline = font.common.base;
+    const descender = lineHeight - baseline;
+    const letterSpacing = options.letterSpacing || 0;
+    const height = lineHeight * lines.length - descender;
+    const alignX = getAlignType(this._options.alignX);
+
+    // draw text along baseline
+    y -= height;
+
+    // the metrics for this text layout
+    this._width = maxLineWidth;
+    this._height = height;
+    this._descender = lineHeight - baseline;
+    this._baseline = baseline;
+    this._xHeight = getXHeight(font);
+    this._capHeight = getCapHeight(font);
+    this._lineHeight = lineHeight;
+    this._ascender = lineHeight - descender - this._xHeight;
+    let wordIndex = 0;
+    let letterIndex = 0;
+
+    // layout each glyph
+    lines.forEach((line, lineIndex) => {
+      const start = line.start;
+      const end = line.end;
+      const lineWidth = line.width;
+      const lineString = text.slice(start, end);
+      const lineWordsTotal = lineString.split(' ').filter(item => item !== '').length;
+      const lineLettersTotal = text.slice(start, end).split(' ').join('').length;
+      let lineLetterIndex = 0;
+      let lineWordIndex = 0;
+      let lastGlyph;
+
+      // for each glyph in that line...
+      for (let i = start; i < end; i++) {
+        const id = text.charCodeAt(i);
+        const glyph = this.getGlyph(font, id);
+        if (glyph) {
+          if (lastGlyph) {
+            x += getKerning(font, lastGlyph.id, glyph.id);
+          }
+          let tx = x;
+          if (alignX === ALIGN_CENTER) {
+            tx += (maxLineWidth - lineWidth) / 2;
+          } else if (alignX === ALIGN_RIGHT) {
+            tx += maxLineWidth - lineWidth;
+          }
+          glyphs.push({
+            position: [tx, y],
+            data: glyph,
+            index: i,
+            // Line
+            linesTotal: lines.length,
+            lineIndex,
+            lineLettersTotal,
+            lineLetterIndex,
+            lineWordsTotal,
+            lineWordIndex,
+            // Word
+            wordsTotal,
+            wordIndex,
+            // Letter
+            lettersTotal,
+            letterIndex
+          });
+          if (glyph.id === SPACE_ID && lastGlyph.id !== SPACE_ID) {
+            lineWordIndex++;
+            wordIndex++;
+          }
+          if (glyph.id !== SPACE_ID) {
+            lineLetterIndex++;
+            letterIndex++;
+          }
+
+          // move pen forward
+          x += glyph.xadvance + letterSpacing;
+          lastGlyph = glyph;
+        }
+      }
+
+      // next line down
+      y += lineHeight;
+      x = 0;
+    });
+    this._lettersTotal = lettersTotal;
+    this._wordsTotal = wordsTotal;
+    this._linesTotal = lines.length;
+  }
+  getGlyph(font, id) {
+    const glyph = getGlyphById(font, id);
+    if (glyph) {
+      return glyph;
+    } else if (id === TAB_ID) {
+      return this._fallbackTabGlyph;
+    } else if (id === SPACE_ID) {
+      return this._fallbackSpaceGlyph;
+    }
+    return null;
+  }
+  computeMetrics(text, start, end, width) {
+    const letterSpacing = this._options.letterSpacing || 0;
+    const font = this._options.font;
+    let curPen = 0;
+    let curWidth = 0;
+    let count = 0;
+    let glyph;
+    let lastGlyph;
+    if (!font.chars || font.chars.length === 0) {
+      return {
+        start,
+        end: start,
+        width: 0
+      };
+    }
+    end = Math.min(text.length, end);
+    for (let i = start; i < end; i++) {
+      const id = text.charCodeAt(i);
+      glyph = this.getGlyph(font, id);
+      if (glyph) {
+        glyph.char = text[i];
+        // move pen forward
+        // const xoff = glyph.xoffset;
+        const kern = lastGlyph ? getKerning(font, lastGlyph.id, glyph.id) : 0;
+        curPen += kern;
+        const nextPen = curPen + glyph.xadvance + letterSpacing;
+        const nextWidth = curPen + glyph.width;
+
+        // we've hit our limit; we can't move onto the next glyph
+        if (nextWidth >= width || nextPen >= width) {
+          break;
+        }
+
+        // otherwise continue along our line
+        curPen = nextPen;
+        curWidth = nextWidth;
+        lastGlyph = glyph;
+      }
+      count++;
+    }
+
+    // make sure rightmost edge lines up with rendered glyphs
+    if (lastGlyph) {
+      curWidth += lastGlyph.xoffset;
+    }
+    return {
+      start,
+      end: start + count,
+      width: curWidth
+    };
+  }
+
+  /**
+   * Private
+   */
+  _setupSpaceGlyphs(font) {
+    var _this$_options$tabSiz;
+    // These are fallbacks, when the font doesn't include
+    // ' ' or '\t' glyphs
+    this._fallbackSpaceGlyph = null;
+    this._fallbackTabGlyph = null;
+    if (!font.chars || font.chars.length === 0) return;
+
+    // try to get space glyph
+    // then fall back to the 'm' or 'w' glyphs
+    // then fall back to the first glyph available
+    const space = getGlyphById(font, SPACE_ID) || getMGlyph(font) || font.chars[0];
+
+    // and create a fallback for tab
+    const tabWidth = ((_this$_options$tabSiz = this._options.tabSize) !== null && _this$_options$tabSiz !== void 0 ? _this$_options$tabSiz : 1) * space.xadvance;
+    this._fallbackSpaceGlyph = space;
+    const spaceClone = Object.assign({}, space);
+    this._fallbackTabGlyph = Object.assign(spaceClone, {
+      x: 0,
+      y: 0,
+      xadvance: tabWidth,
+      id: TAB_ID,
+      xoffset: 0,
+      yoffset: 0,
+      width: 0,
+      height: 0
+    });
+  }
+}
+function createLayout(text, options) {
+  return new TextLayout(text, options);
+}
+function getGlyphById(font, id) {
+  if (!font.chars || font.chars.length === 0) {
+    return null;
+  }
+  const glyphIdx = findChar(font.chars, id);
+  if (glyphIdx >= 0) {
+    const glyph = font.chars[glyphIdx];
+    return glyph;
+  }
+  return null;
+}
+function getXHeight(font) {
+  for (const id of X_HEIGHTS) {
+    const idx = findChar(font.chars, id.charCodeAt(0));
+    if (idx >= 0) {
+      return font.chars[idx].height;
+    }
+  }
+  return 0;
+}
+function getMGlyph(font) {
+  for (const id of M_WIDTHS) {
+    const idx = findChar(font.chars, id.charCodeAt(0));
+    if (idx >= 0) {
+      return font.chars[idx];
+    }
+  }
+  return 0;
+}
+function getCapHeight(font) {
+  for (const id of CAP_HEIGHTS) {
+    const idx = findChar(font.chars, id.charCodeAt(0));
+    if (idx >= 0) {
+      return font.chars[idx].height;
+    }
+  }
+  return 0;
+}
+function getKerning(font, left, right) {
+  if (!font.kernings || font.kernings.length === 0) {
+    return 0;
+  }
+  const table = font.kernings;
+  for (const kern of table) {
+    if (kern.first === left && kern.second === right) {
+      return kern.amount;
+    }
+  }
+  return 0;
+}
+function getAlignType(align) {
+  if (align === 'center') {
+    return ALIGN_CENTER;
+  } else if (align === 'right') {
+    return ALIGN_RIGHT;
+  }
+  return ALIGN_LEFT;
+}
+function findChar(array, value, start) {
+  start = start || 0;
+  for (let i = start; i < array.length; i++) {
+    if (array[i].id === value) {
+      return i;
+    }
+  }
+  return -1;
+}
+function number(num, def) {
+  return typeof num === 'number' ? num : typeof def === 'number' ? def : 0;
+}
+
+export { createLayout, TextLayout as default };

package/text_engine_2d/MSDFTextGeometry/index.cjs.js

@@ -0,0 +1 @@
+"use strict";var t=require("quad-indices"),i=require("three"),s=require("./TextLayout.cjs.js"),e=require("./utils.cjs.js"),r=require("./vertices.cjs.js");function o(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}require("word-wrapper");var n=o(t);const a=new i.Vector3,h=new i.Vector3,u=new i.Vector3,p=new i.Vector3;class c extends i.BufferGeometry{originalPositionsArray=new Float32Array;positionsArray=new Float32Array;positionsAttribute=null;instancesOffsetsCache=[];instancesLengthsCache=[];constructor(t){super(),this._layouts=[],this.update(t)}setTransform(t,i=0){const s=this.instancesOffsetsCache[i],e=this.instancesLengthsCache[i];for(let i=0;i<e;i++){const e=12*s+12*i,r=this.originalPositionsArray[e],o=this.originalPositionsArray[e+1],n=this.originalPositionsArray[e+2],c=this.originalPositionsArray[e+3],l=this.originalPositionsArray[e+4],y=this.originalPositionsArray[e+5],A=this.originalPositionsArray[e+6],g=this.originalPositionsArray[e+7],d=this.originalPositionsArray[e+8],f=this.originalPositionsArray[e+9],b=this.originalPositionsArray[e+10],m=this.originalPositionsArray[e+11];a.set(r,o,n).applyMatrix4(t),h.set(c,l,y).applyMatrix4(t),u.set(A,g,d).applyMatrix4(t),p.set(f,b,m).applyMatrix4(t),this.positionsArray[e]=a.x,this.positionsArray[e+1]=a.y,this.positionsArray[e+2]=a.z,this.positionsArray[e+3]=h.x,this.positionsArray[e+4]=h.y,this.positionsArray[e+5]=h.z,this.positionsArray[e+6]=u.x,this.positionsArray[e+7]=u.y,this.positionsArray[e+8]=u.z,this.positionsArray[e+9]=p.x,this.positionsArray[e+10]=p.y,this.positionsArray[e+11]=p.z}this.positionsAttribute&&(this.positionsAttribute.needsUpdate=!0)}update(t){const{texts:e,...o}=t;this._layouts=e.map((t=>s.createLayout(t.text,{...o,...t})));const a=!1!==t.flipY,h=t.font,u=h.common.scaleW,p=h.common.scaleH,c=this._layouts.map((t=>t.glyphs.filter((t=>{const i=t.data;return i.width*i.height>0}))));this.instancesOffsetsCache=[],this.instancesLengthsCache=[];let l=0;c.forEach(((t,i)=>{this.instancesLengthsCache[i]=t.length,this.instancesOffsetsCache[i]=l,l+=t.length}));const y=l,A=n.default([],{clockwise:!0,type:"uint16",count:y});this.setIndex(A);const g=c.map((t=>r.generateAttributes(t,u,p,a))),d=g.reduce(((t,i)=>t+i.positions.length),0),f=g.reduce(((t,i)=>t+i.centers.length),0),b=g.reduce(((t,i)=>t+i.uvs.length),0),m=new Float32Array(d),x=new Float32Array(f),w=new Float32Array(b);let P=0,B=0,S=0;g.forEach((t=>{m.set(t.positions,P),P+=t.positions.length,x.set(t.centers,B),B+=t.centers.length,w.set(t.uvs,S),S+=t.uvs.length})),this.positionsArray=m,this.originalPositionsArray=new Float32Array(d),this.originalPositionsArray.set(m),this.positionsAttribute=new i.BufferAttribute(m,3),this.setAttribute("position",this.positionsAttribute),this.setAttribute("center",new i.BufferAttribute(x,2)),this.setAttribute("uv",new i.BufferAttribute(w,2))}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new i.Sphere);const t=this.attributes.position.array,s=this.attributes.position.itemSize;if(!t||!s||t.length<2)return this.boundingSphere.radius=0,void this.boundingSphere.center.set(0,0,0);e.computeSphere(t,this.boundingSphere),isNaN(this.boundingSphere.radius)&&console.error('BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.')}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new i.Box3);const t=this.boundingBox,s=this.attributes.position.array,r=this.attributes.position.itemSize;if(!s||!r||s.length<2)return void t.makeEmpty();return e.computeBox(s,t)}}module.exports=c;

package/text_engine_2d/MSDFTextGeometry/index.d.ts

@@ -0,0 +1,51 @@
+import { BufferGeometry, Box3, BufferAttribute, Matrix4 } from 'three';
+import TextLayout from './TextLayout';
+export interface IInstance {
+    text: string;
+    lineHeight?: number;
+    letterSpacing?: number;
+    alignX?: string;
+    alignY?: string;
+    width?: number;
+    yShift?: number;
+}
+export interface IOptions {
+    texts: IInstance[];
+    flipY?: boolean;
+    font?: any;
+    tabSize?: number;
+    width?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    alignX?: string;
+    alignY?: string;
+    yShift?: number;
+}
+export interface IGlyph {
+    position: [number, number];
+    data: any;
+    index: number;
+    linesTotal: number;
+    lineIndex: number;
+    lineLettersTotal: number;
+    lineLetterIndex: number;
+    lineWordsTotal: number;
+    lineWordIndex: number;
+    wordsTotal: number;
+    wordIndex: number;
+    lettersTotal: number;
+    letterIndex: number;
+}
+export default class MSDFTextGeometry extends BufferGeometry {
+    _layouts: TextLayout[];
+    originalPositionsArray: Float32Array;
+    positionsArray: Float32Array;
+    positionsAttribute: BufferAttribute | null;
+    instancesOffsetsCache: number[];
+    instancesLengthsCache: number[];
+    constructor(options: IOptions);
+    setTransform(transform: Matrix4, instance?: number): void;
+    update(options: IOptions): void;
+    computeBoundingSphere(): void;
+    computeBoundingBox(): Box3 | undefined;
+}

package/text_engine_2d/MSDFTextGeometry/index.js

@@ -0,0 +1,159 @@
+import createIndices from 'quad-indices';
+import { BufferGeometry, BufferAttribute, Sphere, Box3, Vector3 } from 'three';
+import { createLayout } from './TextLayout.js';
+import { computeSphere, computeBox } from './utils.js';
+import { generateAttributes } from './vertices.js';
+
+// @ts-ignore-next-line
+// TEMP for optimizing allocations
+const pointA = new Vector3();
+const pointB = new Vector3();
+const pointC = new Vector3();
+const pointD = new Vector3();
+class MSDFTextGeometry extends BufferGeometry {
+  originalPositionsArray = new Float32Array();
+  positionsArray = new Float32Array();
+  positionsAttribute = null;
+  instancesOffsetsCache = [];
+  instancesLengthsCache = [];
+  constructor(options) {
+    super();
+    this._layouts = [];
+    this.update(options);
+  }
+  setTransform(transform, instance = 0) {
+    const instanceOffset = this.instancesOffsetsCache[instance];
+    const instanceLength = this.instancesLengthsCache[instance];
+    for (let i = 0; i < instanceLength; i++) {
+      const instanceGlyphOffset = instanceOffset * 12 + i * 12;
+      const originalXA = this.originalPositionsArray[instanceGlyphOffset];
+      const originalYA = this.originalPositionsArray[instanceGlyphOffset + 1];
+      const originalZA = this.originalPositionsArray[instanceGlyphOffset + 2];
+      const originalXB = this.originalPositionsArray[instanceGlyphOffset + 3];
+      const originalYB = this.originalPositionsArray[instanceGlyphOffset + 4];
+      const originalZB = this.originalPositionsArray[instanceGlyphOffset + 5];
+      const originalXC = this.originalPositionsArray[instanceGlyphOffset + 6];
+      const originalYC = this.originalPositionsArray[instanceGlyphOffset + 7];
+      const originalZC = this.originalPositionsArray[instanceGlyphOffset + 8];
+      const originalXD = this.originalPositionsArray[instanceGlyphOffset + 9];
+      const originalYD = this.originalPositionsArray[instanceGlyphOffset + 10];
+      const originalZD = this.originalPositionsArray[instanceGlyphOffset + 11];
+      pointA.set(originalXA, originalYA, originalZA).applyMatrix4(transform);
+      pointB.set(originalXB, originalYB, originalZB).applyMatrix4(transform);
+      pointC.set(originalXC, originalYC, originalZC).applyMatrix4(transform);
+      pointD.set(originalXD, originalYD, originalZD).applyMatrix4(transform);
+      this.positionsArray[instanceGlyphOffset] = pointA.x;
+      this.positionsArray[instanceGlyphOffset + 1] = pointA.y;
+      this.positionsArray[instanceGlyphOffset + 2] = pointA.z;
+      this.positionsArray[instanceGlyphOffset + 3] = pointB.x;
+      this.positionsArray[instanceGlyphOffset + 4] = pointB.y;
+      this.positionsArray[instanceGlyphOffset + 5] = pointB.z;
+      this.positionsArray[instanceGlyphOffset + 6] = pointC.x;
+      this.positionsArray[instanceGlyphOffset + 7] = pointC.y;
+      this.positionsArray[instanceGlyphOffset + 8] = pointC.z;
+      this.positionsArray[instanceGlyphOffset + 9] = pointD.x;
+      this.positionsArray[instanceGlyphOffset + 10] = pointD.y;
+      this.positionsArray[instanceGlyphOffset + 11] = pointD.z;
+    }
+    if (this.positionsAttribute) {
+      this.positionsAttribute.needsUpdate = true;
+    }
+  }
+  update(options) {
+    const {
+      texts,
+      ...optionsWithoutTexts
+    } = options;
+    this._layouts = texts.map(txt => createLayout(txt.text, {
+      ...optionsWithoutTexts,
+      ...txt
+    }));
+
+    // get vec2 texcoords
+    const flipY = options.flipY !== false;
+
+    // the desired BMFont data
+    const font = options.font;
+
+    // determine texture size from font file
+    const texWidth = font.common.scaleW;
+    const texHeight = font.common.scaleH;
+    const glyphs = this._layouts.map(lay => lay.glyphs.filter(glyph => {
+      const bitmap = glyph.data;
+      return bitmap.width * bitmap.height > 0;
+    }));
+
+    // Keep a cache of each text instance offset and length for attributes
+    this.instancesOffsetsCache = [];
+    this.instancesLengthsCache = [];
+    let offsetSoFar = 0;
+    glyphs.forEach((t, i) => {
+      this.instancesLengthsCache[i] = t.length;
+      this.instancesOffsetsCache[i] = offsetSoFar;
+      offsetSoFar += t.length;
+    });
+    const totalGlyphsLength = offsetSoFar;
+    const indices = createIndices([], {
+      clockwise: true,
+      type: 'uint16',
+      count: totalGlyphsLength
+    });
+    this.setIndex(indices);
+    const attributes = glyphs.map(glyph => generateAttributes(glyph, texWidth, texHeight, flipY));
+    const positionsTotalLength = attributes.reduce((sum, at) => sum + at.positions.length, 0);
+    const centersTotalLength = attributes.reduce((sum, at) => sum + at.centers.length, 0);
+    const uvsTotalLength = attributes.reduce((sum, at) => sum + at.uvs.length, 0);
+    const positions = new Float32Array(positionsTotalLength);
+    const centers = new Float32Array(centersTotalLength);
+    const uvs = new Float32Array(uvsTotalLength);
+    let positionsPos = 0;
+    let centersPos = 0;
+    let uvsPos = 0;
+    attributes.forEach(at => {
+      positions.set(at.positions, positionsPos);
+      positionsPos += at.positions.length;
+      centers.set(at.centers, centersPos);
+      centersPos += at.centers.length;
+      uvs.set(at.uvs, uvsPos);
+      uvsPos += at.uvs.length;
+    });
+    this.positionsArray = positions;
+    this.originalPositionsArray = new Float32Array(positionsTotalLength);
+    this.originalPositionsArray.set(positions);
+    this.positionsAttribute = new BufferAttribute(positions, 3);
+    this.setAttribute('position', this.positionsAttribute);
+    this.setAttribute('center', new BufferAttribute(centers, 2));
+    this.setAttribute('uv', new BufferAttribute(uvs, 2));
+  }
+  computeBoundingSphere() {
+    if (this.boundingSphere === null) this.boundingSphere = new Sphere();
+    const positions = this.attributes.position.array;
+    const itemSize = this.attributes.position.itemSize;
+    if (!positions || !itemSize || positions.length < 2) {
+      this.boundingSphere.radius = 0;
+      this.boundingSphere.center.set(0, 0, 0);
+      return;
+    }
+    computeSphere(positions, this.boundingSphere);
+    if (isNaN(this.boundingSphere.radius)) {
+      // eslint-disable-next-line no-console
+      console.error('BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.');
+    }
+  }
+  computeBoundingBox() {
+    if (this.boundingBox === null) {
+      this.boundingBox = new Box3();
+    }
+    const bbox = this.boundingBox;
+    const positions = this.attributes.position.array;
+    const itemSize = this.attributes.position.itemSize;
+    if (!positions || !itemSize || positions.length < 2) {
+      bbox.makeEmpty();
+      return;
+    }
+    const box = computeBox(positions, bbox);
+    return box;
+  }
+}
+
+export { MSDFTextGeometry as default };

package/text_engine_2d/MSDFTextGeometry/utils.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const m=3,n={min:[0,0,0],max:[0,0,0]};function t(t){const a=t.length/m;n.min[0]=t[0],n.min[1]=t[1],n.max[0]=t[0],n.max[1]=t[1];for(let i=0;i<a;i++){const a=t[i*m+0],e=t[i*m+1],x=t[i*m+2];n.min[0]=Math.min(a,n.min[0]),n.min[1]=Math.min(e,n.min[1]),n.min[2]=Math.min(x,n.min[2]),n.max[0]=Math.max(a,n.max[0]),n.max[1]=Math.max(e,n.max[1]),n.max[2]=Math.max(x,n.max[2])}}exports.computeBox=function(m,a){return t(m),a.min.set(n.min[0],n.min[1],n.min[2]),a.max.set(n.max[0],n.max[1],n.max[2]),a},exports.computeSphere=function(m,a){t(m);const i=n.min[0],e=n.min[1],x=n.min[2],o=n.max[0]-i,s=n.max[1]-e,r=n.max[2]-x,c=Math.sqrt(o*o+s*s+r*r);a.center.set(i+o/2,e+s/2,x+r/2),a.radius=c/2};

package/text_engine_2d/MSDFTextGeometry/utils.d.ts

@@ -0,0 +1,3 @@
+import { Box3, Sphere } from 'three';
+export declare function computeBox(positions: ArrayLike<number>, output: Box3): Box3;
+export declare function computeSphere(positions: ArrayLike<number>, output: Sphere): void;

package/text_engine_2d/MSDFTextGeometry/utils.js

@@ -0,0 +1,46 @@
+const itemSize = 3;
+const box = {
+  min: [0, 0, 0],
+  max: [0, 0, 0]
+};
+function bounds(positions) {
+  const count = positions.length / itemSize;
+  box.min[0] = positions[0];
+  box.min[1] = positions[1];
+  box.max[0] = positions[0];
+  box.max[1] = positions[1];
+  for (let i = 0; i < count; i++) {
+    const x = positions[i * itemSize + 0];
+    const y = positions[i * itemSize + 1];
+    const z = positions[i * itemSize + 2];
+    box.min[0] = Math.min(x, box.min[0]);
+    box.min[1] = Math.min(y, box.min[1]);
+    box.min[2] = Math.min(z, box.min[2]);
+    box.max[0] = Math.max(x, box.max[0]);
+    box.max[1] = Math.max(y, box.max[1]);
+    box.max[2] = Math.max(z, box.max[2]);
+  }
+}
+function computeBox(positions, output) {
+  bounds(positions);
+  output.min.set(box.min[0], box.min[1], box.min[2]);
+  output.max.set(box.max[0], box.max[1], box.max[2]);
+  return output;
+}
+function computeSphere(positions, output) {
+  bounds(positions);
+  const minX = box.min[0];
+  const minY = box.min[1];
+  const minZ = box.min[2];
+  const maxX = box.max[0];
+  const maxY = box.max[1];
+  const maxZ = box.max[2];
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const depth = maxZ - minZ;
+  const length = Math.sqrt(width * width + height * height + depth * depth);
+  output.center.set(minX + width / 2, minY + height / 2, minZ + depth / 2);
+  output.radius = length / 2;
+}
+
+export { computeBox, computeSphere };

package/text_engine_2d/MSDFTextGeometry/vertices.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.generateAttributes=function(t,e,o,n){const s=new Float32Array(4*t.length*2),r=new Float32Array(4*t.length*3),i=new Float32Array(4*t.length*2);let a=0,l=0,c=0;return t.forEach((function(t){const h=t.data,f=h.x+h.width,u=h.y+h.height,y=h.x/e;let g=h.y/o;const p=f/e;let d=u/o;n&&(g=(o-h.y)/o,d=(o-u)/o),s[a++]=y,s[a++]=g,s[a++]=y,s[a++]=d,s[a++]=p,s[a++]=d,s[a++]=p,s[a++]=g;const w=t.position[0]+h.xoffset,x=t.position[1]+h.yoffset,A=h.width,F=h.height;r[l++]=w,r[l++]=x,r[l++]=0,r[l++]=w,r[l++]=x+F,r[l++]=0,r[l++]=w+A,r[l++]=x+F,r[l++]=0,r[l++]=w+A,r[l++]=x,r[l++]=0,i[c++]=w+A/2,i[c++]=x+F/2,i[c++]=w+A/2,i[c++]=x+F/2,i[c++]=w+A/2,i[c++]=x+F/2,i[c++]=w+A/2,i[c++]=x+F/2})),{uvs:s,positions:r,centers:i}};

package/text_engine_2d/MSDFTextGeometry/vertices.d.ts

@@ -0,0 +1,28 @@
+type Glyph = {
+    data: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        page: number;
+        xoffset: number;
+        yoffset: number;
+    };
+    position: [number, number];
+    linesTotal: number;
+    lineIndex: number;
+    lineLettersTotal: number;
+    lineLetterIndex: number;
+    lineWordsTotal: number;
+    lineWordIndex: number;
+    wordsTotal: number;
+    wordIndex: number;
+    lettersTotal: number;
+    letterIndex: number;
+};
+export declare function generateAttributes(glyphs: Glyph[], texWidth: number, texHeight: number, flipY: boolean): {
+    uvs: Float32Array;
+    positions: Float32Array;
+    centers: Float32Array;
+};
+export {};