p5 2.0.0 → 2.0.2

package/{src → dist}/webgl/text.js

@@ -1,32 +1,57 @@
-import * as constants from "../core/constants";
-import { RendererGL } from "./p5.RendererGL";
-import { Vector } from "../math/p5.Vector";
-import { Geometry } from "./p5.Geometry";
-import { Font, arrayCommandsToObjects } from "../type/p5.Font";
+import { T as TEXTURE } from '../constants-tYr0tCl8.js';
+import { R as RendererGL } from '../rendering-B5TRR7aY.js';
+import { Vector } from '../math/p5.Vector.js';
+import { Geometry } from './p5.Geometry.js';
+import { Font, arrayCommandsToObjects } from '../type/p5.Font.js';
+import '../creating_reading-Cr8L2Jnm.js';
+import 'colorjs.io/fn';
+import '../color/color_spaces/hsb.js';
+import '../dom/p5.Element.js';
+import '../dom/p5.File.js';
+import '../io/p5.XML.js';
+import '../p5.Renderer-Swjl9HQO.js';
+import '../image/filters.js';
+import '../shape/custom_shapes.js';
+import '../core/States.js';
+import '../io/utilities.js';
+import 'file-saver';
+import '../dom/p5.MediaElement.js';
+import '../shape/2d_primitives.js';
+import '../core/helpers.js';
+import '../shape/attributes.js';
+import '../shape/curves.js';
+import '../shape/vertex.js';
+import '../color/setting.js';
+import 'omggif';
+import '../io/csv.js';
+import 'gifenc';
+import '../image/pixels.js';
+import '../core/transform.js';
+import './GeometryBuilder.js';
+import '../math/p5.Matrix.js';
+import '../math/Matrices/Matrix.js';
+import '../math/Matrices/MatrixInterface.js';
+import './p5.Quat.js';
+import './p5.RenderBuffer.js';
+import './p5.DataArray.js';
+import './ShapeBuilder.js';
+import 'libtess';
+import './GeometryBufferCache.js';
+import '../image/const.js';
+import '../math/trigonometry.js';
+import '../type/textCore.js';
+import '@japont/unicode-range';
+import '../type/unicodeRanges.js';
+import '../type/lib/Typr.js';
+import 'pako';
+import '@davepagurek/bezier-path';
 
 function text(p5, fn) {
   RendererGL.prototype.maxCachedGlyphs = function() {
     // TODO: use more than vibes to find a good value for this
-    return 200
+    return 200;
   };
 
-  RendererGL.prototype.freeGlyphInfo = function(gi) {
-    const datas = [
-      gi.strokeImageInfo.imageData,
-      gi.rowInfo.cellImageInfo.imageData,
-      gi.rowInfo.dimImageInfo.imageData,
-      gi.colInfo.cellImageInfo.imageData,
-      gi.colInfo.dimImageInfo.imageData,
-    ];
-    for (const data of datas) {
-      const tex = this.textures.get(data);
-      if (tex) {
-        tex.remove();
-        this.textures.delete(data);
-      }
-    }
-  }
-
   Font.prototype._getFontInfo = function(axs) {
     // For WebGL, a cache of font data to use on the GPU.
     this._fontInfos = this._fontInfos || {};
@@ -40,7 +65,7 @@ function text(p5, fn) {
       this._fontInfos[key] = val;
       return val;
     }
-  }
+  };
 
   // Text/Typography (see src/type/textCore.js)
   /*
@@ -716,7 +741,7 @@ function text(p5, fn) {
     const drawMode = this.states.drawMode;
 
     this.states.setValue("strokeColor", null);
-    this.states.setValue("drawMode", constants.TEXTURE);
+    this.states.setValue("drawMode", TEXTURE);
 
     // get the cached FontInfo object
     const { font } = this.states.textFont;
@@ -792,7 +817,7 @@ function text(p5, fn) {
     sh.setUniform("uMaterialColor", curFillColor);
     gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
 
-    this.fontCache = this.fontCache || new Map();
+    this.glyphDataCache = this.glyphDataCache || new Set();
 
     try {
       // fetch the glyphs in the line of text
@@ -801,20 +826,35 @@ function text(p5, fn) {
       for (const glyph of glyphs) {
         const gi = fontInfo.getGlyphInfo(glyph);
         if (gi.uGlyphRect) {
+          const rowInfo = gi.rowInfo;
+          const colInfo = gi.colInfo;
 
-          const cacheKey = JSON.stringify({ font: font.id, axs, glyph: glyph.shape.g });
-          // Bump this font to the end of the cache list by deleting and re-adding it
-          this.fontCache.delete(cacheKey);
-          this.fontCache.set(cacheKey, gi);
-          if (this.fontCache.size > this.maxCachedGlyphs()) {
-            const keyToRemove = this.fontCache.keys().next().value;
-            const val = this.fontCache.get(keyToRemove);
-            this.fontCache.delete(keyToRemove);
-            this.freeGlyphInfo(val);
+          // Bump the resources for this glyph to the end of the cache list by deleting and re-adding
+          const glyphResources = [
+            gi.strokeImageInfo.imageData,
+            rowInfo.cellImageInfo.imageData,
+            rowInfo.dimImageInfo.imageData,
+            colInfo.cellImageInfo.imageData,
+            colInfo.dimImageInfo.imageData
+          ];
+          for (const resource of glyphResources) {
+            this.glyphDataCache.delete(resource);
+            this.glyphDataCache.add(resource);
+          }
+
+          // If we have too many glyph textures, remove the least recently used
+          // ones from GPU memory. The data still exists on the CPU and will be
+          // re-uploaded if it gets actively used again.
+          while (this.glyphDataCache.size > this.maxCachedGlyphs()) {
+            const data = this.glyphDataCache.values().next().value;
+            this.glyphDataCache.delete(data);
+            const tex = this.textures.get(data);
+            if (tex) {
+              tex.remove();
+              this.textures.delete(data);
+            }
           }
 
-          const rowInfo = gi.rowInfo;
-          const colInfo = gi.colInfo;
           sh.setUniform("uSamplerStrokes", gi.strokeImageInfo.imageData);
           sh.setUniform("uSamplerRowStrokes", rowInfo.cellImageInfo.imageData);
           sh.setUniform("uSamplerRows", rowInfo.dimImageInfo.imageData);
@@ -843,4 +883,4 @@ function text(p5, fn) {
   };
 }
 
-export default text;
+export { text as default };