three-stdlib 2.6.4 → 2.7.0

package/index.d.ts

@@ -246,6 +246,7 @@ export * from './geometries/RoundedBoxGeometry';
 export * from './geometries/BoxLineGeometry';
 export * from './geometries/DecalGeometry';
 export * from './geometries/TeapotGeometry';
+export * from './geometries/TextGeometry';
 export * from './csm/CSM';
 export * from './csm/Shader';
 export * from './csm/CSMHelper';
@@ -312,6 +313,7 @@ export * from './effects/AnaglyphEffect';
 export * from './effects/AsciiEffect';
 export * from './effects/StereoEffect';
 export * from './loaders/FBXLoader';
+export * from './loaders/FontLoader';
 export * from './loaders/TGALoader';
 export * from './loaders/LUTCubeLoader';
 export * from './loaders/NRRDLoader';

package/index.js

@@ -191,6 +191,7 @@ export { RoundedBoxGeometry } from './geometries/RoundedBoxGeometry.js';
 export { BoxLineGeometry } from './geometries/BoxLineGeometry.js';
 export { DecalGeometry, DecalVertex } from './geometries/DecalGeometry.js';
 export { TeapotGeometry } from './geometries/TeapotGeometry.js';
+export { TextGeometry as TextBufferGeometry, TextGeometry } from './geometries/TextGeometry.js';
 export { CSM } from './csm/CSM.js';
 export { CSMHelper } from './csm/CSMHelper.js';
 export { SMAABlendShader, SMAAEdgesShader, SMAAWeightsShader } from './shaders/SMAAShader.js';
@@ -255,6 +256,7 @@ export { AnaglyphEffect } from './effects/AnaglyphEffect.js';
 export { AsciiEffect } from './effects/AsciiEffect.js';
 export { StereoEffect } from './effects/StereoEffect.js';
 export { FBXLoader } from './loaders/FBXLoader.js';
+export { Font, FontLoader } from './loaders/FontLoader.js';
 export { TGALoader } from './loaders/TGALoader.js';
 export { LUTCubeLoader } from './loaders/LUTCubeLoader.js';
 export { NRRDLoader } from './loaders/NRRDLoader.js';

package/loaders/FontLoader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),t=require("three");function r(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var s=r(e);class a extends t.Loader{constructor(e){super(e)}load(e,r,s,a){const n=new t.FileLoader(this.manager);n.setPath(this.path),n.setRequestHeader(this.requestHeader),n.setWithCredentials(this.withCredentials),n.load(e,(e=>{if("string"!=typeof e)throw new Error("unsupported data type");const t=JSON.parse(e),s=this.parse(t);r&&r(s)}),s,a)}parse(e){return new n(e)}}class n{constructor(e){s.default(this,"data",void 0),this.data=e}generateShapes(e,t=100){const r=[],s=function(e,t,r){const s=Array.from(e),a=t/r.resolution,n=(r.boundingBox.yMax-r.boundingBox.yMin+r.underlineThickness)*a,i=[];let p=0,l=0;for(let e=0;e<s.length;e++){const t=s[e];if("\n"===t)p=0,l-=n;else{const e=o(t,a,p,l,r);e&&(p+=e.offsetX,i.push(e.path))}}return i}(e,t,this.data);for(let e=0,t=s.length;e<t;e++)Array.prototype.push.apply(r,s[e].toShapes(!1));return r}}function o(e,r,s,a,n){const o=n.glyphs[e]||n.glyphs["?"];if(!o)return void console.error('THREE.Font: character "'+e+'" does not exists in font family '+n.familyName+".");const i=new t.ShapePath;let p,l,u,c,d,h,f,y;if(o.o){const e=o._cachedOutline||(o._cachedOutline=o.o.split(" "));for(let t=0,n=e.length;t<n;){switch(e[t++]){case"m":p=parseInt(e[t++])*r+s,l=parseInt(e[t++])*r+a,i.moveTo(p,l);break;case"l":p=parseInt(e[t++])*r+s,l=parseInt(e[t++])*r+a,i.lineTo(p,l);break;case"q":u=parseInt(e[t++])*r+s,c=parseInt(e[t++])*r+a,d=parseInt(e[t++])*r+s,h=parseInt(e[t++])*r+a,i.quadraticCurveTo(d,h,u,c);break;case"b":u=parseInt(e[t++])*r+s,c=parseInt(e[t++])*r+a,d=parseInt(e[t++])*r+s,h=parseInt(e[t++])*r+a,f=parseInt(e[t++])*r+s,y=parseInt(e[t++])*r+a,i.bezierCurveTo(d,h,f,y,u,c)}}}return{offsetX:o.ha*r,path:i}}s.default(n,"isFont",void 0),s.default(n,"type",void 0),exports.Font=n,exports.FontLoader=a;

package/loaders/FontLoader.d.ts

@@ -0,0 +1,32 @@
+import { Loader } from 'three';
+import type { LoadingManager, Shape } from 'three';
+export declare class FontLoader extends Loader {
+    constructor(manager?: LoadingManager);
+    load(url: string, onLoad?: (responseFont: Font) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+    parse(json: FontData): Font;
+}
+declare type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+declare type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+export declare class Font {
+    data: FontData;
+    static isFont: true;
+    static type: 'Font';
+    constructor(data: FontData);
+    generateShapes(text: string, size?: number): Shape[];
+}
+export {};

package/loaders/FontLoader.js

@@ -0,0 +1,139 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { Loader, FileLoader, ShapePath } from 'three';
+
+class FontLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+  }
+
+  load(url, onLoad, onProgress, onError) {
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(url, response => {
+      if (typeof response !== 'string') throw new Error('unsupported data type');
+      const json = JSON.parse(response);
+      const font = this.parse(json);
+      if (onLoad) onLoad(font);
+    }, onProgress, onError);
+  }
+
+  parse(json) {
+    return new Font(json);
+  }
+
+}
+class Font {
+  constructor(data) {
+    _defineProperty(this, "data", void 0);
+
+    this.data = data;
+  }
+
+  generateShapes(text, size = 100) {
+    const shapes = [];
+    const paths = createPaths(text, size, this.data);
+
+    for (let p = 0, pl = paths.length; p < pl; p++) {
+      Array.prototype.push.apply(shapes, paths[p].toShapes(false));
+    }
+
+    return shapes;
+  }
+
+}
+
+_defineProperty(Font, "isFont", void 0);
+
+_defineProperty(Font, "type", void 0);
+
+function createPaths(text, size, data) {
+  const chars = Array.from(text);
+  const scale = size / data.resolution;
+  const line_height = (data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness) * scale;
+  const paths = [];
+  let offsetX = 0,
+      offsetY = 0;
+
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+
+    if (char === '\n') {
+      offsetX = 0;
+      offsetY -= line_height;
+    } else {
+      const ret = createPath(char, scale, offsetX, offsetY, data);
+
+      if (ret) {
+        offsetX += ret.offsetX;
+        paths.push(ret.path);
+      }
+    }
+  }
+
+  return paths;
+}
+
+function createPath(char, scale, offsetX, offsetY, data) {
+  const glyph = data.glyphs[char] || data.glyphs['?'];
+
+  if (!glyph) {
+    console.error('THREE.Font: character "' + char + '" does not exists in font family ' + data.familyName + '.');
+    return;
+  }
+
+  const path = new ShapePath();
+  let x, y, cpx, cpy, cpx1, cpy1, cpx2, cpy2;
+
+  if (glyph.o) {
+    const outline = glyph._cachedOutline || (glyph._cachedOutline = glyph.o.split(' '));
+
+    for (let i = 0, l = outline.length; i < l;) {
+      const action = outline[i++];
+
+      switch (action) {
+        case 'm':
+          // moveTo
+          x = parseInt(outline[i++]) * scale + offsetX;
+          y = parseInt(outline[i++]) * scale + offsetY;
+          path.moveTo(x, y);
+          break;
+
+        case 'l':
+          // lineTo
+          x = parseInt(outline[i++]) * scale + offsetX;
+          y = parseInt(outline[i++]) * scale + offsetY;
+          path.lineTo(x, y);
+          break;
+
+        case 'q':
+          // quadraticCurveTo
+          cpx = parseInt(outline[i++]) * scale + offsetX;
+          cpy = parseInt(outline[i++]) * scale + offsetY;
+          cpx1 = parseInt(outline[i++]) * scale + offsetX;
+          cpy1 = parseInt(outline[i++]) * scale + offsetY;
+          path.quadraticCurveTo(cpx1, cpy1, cpx, cpy);
+          break;
+
+        case 'b':
+          // bezierCurveTo
+          cpx = parseInt(outline[i++]) * scale + offsetX;
+          cpy = parseInt(outline[i++]) * scale + offsetY;
+          cpx1 = parseInt(outline[i++]) * scale + offsetX;
+          cpy1 = parseInt(outline[i++]) * scale + offsetY;
+          cpx2 = parseInt(outline[i++]) * scale + offsetX;
+          cpy2 = parseInt(outline[i++]) * scale + offsetY;
+          path.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, cpx, cpy);
+          break;
+      }
+    }
+  }
+
+  return {
+    offsetX: glyph.ha * scale,
+    path
+  };
+}
+
+export { Font, FontLoader };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.6.4",
+  "version": "2.7.0",
   "private": false,
   "description": "stand-alone library of threejs examples",
   "main": "index.cjs.js",