@expofp/renderer 2.3.1 → 2.3.3

package/dist/index.js

@@ -1472,6 +1472,7 @@ class ImageSystem extends RenderableSystem {
     /** Textures memory limit in megabytes */
     __publicField(this, "memoryLimitMb");
     __publicField(this, "packer");
+    __publicField(this, "originalAtlases", /* @__PURE__ */ new Map());
     __publicField(this, "globalTranslationMatrix", new Matrix4());
     __publicField(this, "originTranslationMatrix", new Matrix4());
     __publicField(this, "rotationMatrix", new Matrix4());
@@ -1482,6 +1483,10 @@ class ImageSystem extends RenderableSystem {
     const padding = 1;
     this.packer = new MaxRectsPacker(atlasTextureSize, atlasTextureSize, padding, { pot: false });
   }
+  dispose() {
+    super.dispose();
+    this.originalAtlases.clear();
+  }
   updateLayerImpl(group, layerDef) {
     super.updateLayerImpl(group, layerDef);
     if (this.memoryLimitMb) this.resizeTextures();
@@ -1517,13 +1522,15 @@ class ImageSystem extends RenderableSystem {
         this.registerDefObject(def, batchedMesh, instanceId);
       }
       const nonResizable = rectsWithDef.some(({ def }) => def.source instanceof HTMLCanvasElement);
-      batchedMesh.userData["nonResizable"] = nonResizable;
+      if (!nonResizable) this.originalAtlases.set(batchedMesh, texture.image);
       group.add(batchedMesh);
     }
     return group;
   }
   /**
    * Resize textures to fit the memory limit.
+   * Uses stored original atlases so that every call computes a globally proportional
+   * resize factor, regardless of how many layers have been loaded so far.
    */
   resizeTextures() {
     var _a2;
@@ -1532,47 +1539,54 @@ class ImageSystem extends RenderableSystem {
       return;
     }
     logger$9.debug(`Resizing textures to fit memory limit: ${this.memoryLimitMb} MB`);
-    const texturesToResize = [];
-    let totalResizable = 0;
+    const resizableMeshes = [];
+    let totalOriginal = 0;
     let totalNonResizable = 0;
     for (const mesh of this.getAllObjects()) {
+      const originalCanvas = this.originalAtlases.get(mesh);
       const texture = mesh.material.map;
-      const imageBytes = getTextureSizeBytes(texture);
-      const nonResizable = mesh.userData["nonResizable"];
-      if (nonResizable) {
-        totalNonResizable += imageBytes;
+      if (originalCanvas) {
+        totalOriginal += getCanvasSizeBytes(originalCanvas, texture.generateMipmaps);
+        resizableMeshes.push(mesh);
       } else {
-        totalResizable += imageBytes;
-        texturesToResize.push(mesh);
+        totalNonResizable += getCanvasSizeBytes(texture.image, texture.generateMipmaps);
       }
     }
+    if (resizableMeshes.length === 0) {
+      logger$9.debug("No resizable meshes found, no need to resize textures.");
+      return;
+    }
     const budget = this.memoryLimitMb * 1024 * 1024 - totalNonResizable;
     if (budget < 0) {
       logger$9.debug("Memory limit is too low, unable to resize textures.");
       return;
     }
-    const resizeFactor = Math.sqrt(budget / totalResizable);
+    const resizeFactor = Math.sqrt(budget / totalOriginal);
     if (resizeFactor >= 1) {
       logger$9.debug("Textures are already within the memory limit, no need to resize");
       return;
     }
     logger$9.debug(`Resize factor: ${resizeFactor}`);
     let newTotal = totalNonResizable;
-    for (const mesh of texturesToResize) {
+    for (const mesh of resizableMeshes) {
       const material = mesh.material;
-      const texture = material.map;
-      const resizedTexture = resizeTexture(texture, resizeFactor);
-      const textureDim = `${texture.image.width}x${texture.image.height}`;
+      const currentTexture = material.map;
+      const originalCanvas = this.originalAtlases.get(mesh);
+      const resizedTexture = resizeCanvas(originalCanvas, resizeFactor);
+      const originalDim = `${originalCanvas.width}x${originalCanvas.height}`;
       const resizedDim = `${resizedTexture.image.width}x${resizedTexture.image.height}`;
-      logger$9.debug(`Resized atlas for ${mesh.name || ((_a2 = mesh.parent) == null ? void 0 : _a2.name)}, from ${textureDim} to ${resizedDim}`);
-      newTotal += getTextureSizeBytes(resizedTexture);
+      logger$9.debug(`Resized atlas for ${mesh.name || ((_a2 = mesh.parent) == null ? void 0 : _a2.name)}, from ${originalDim} to ${resizedDim}`);
+      newTotal += getCanvasSizeBytes(resizedTexture.image, resizedTexture.generateMipmaps);
       material.map = resizedTexture;
       material.needsUpdate = true;
-      texture.dispose();
-      mesh.userData["nonResizable"] = true;
+      currentTexture.dispose();
     }
     logger$9.debug(`New memory usage after resizing: ${newTotal} bytes`);
   }
+  disposeObject(object) {
+    this.originalAtlases.delete(object);
+    super.disposeObject(object);
+  }
   updateDefImpl(imageDef, mesh, instanceIds) {
     const instanceId = instanceIds[0];
     const bounds = imageDef.bounds;
@@ -1630,12 +1644,12 @@ function createAtlas(bin) {
   logger$9.debug(`Create atlas took ${(t1 - t0).toFixed(2)} milliseconds.`);
   return createTexture(canvas);
 }
-function resizeTexture(texture, resizeFactor) {
+function resizeCanvas(source, resizeFactor) {
   const canvas = document.createElement("canvas");
-  canvas.width = Math.floor(texture.image.width * resizeFactor);
-  canvas.height = Math.floor(texture.image.height * resizeFactor);
+  canvas.width = Math.floor(source.width * resizeFactor);
+  canvas.height = Math.floor(source.height * resizeFactor);
   const ctx = canvas.getContext("2d");
-  ctx.drawImage(texture.image, 0, 0, canvas.width, canvas.height);
+  ctx.drawImage(source, 0, 0, canvas.width, canvas.height);
   return createTexture(canvas);
 }
 function createTexture(source) {
@@ -1646,9 +1660,8 @@ function createTexture(source) {
   texture.needsUpdate = true;
   return texture;
 }
-function getTextureSizeBytes(texture) {
-  const imageBytes = texture.image.width * texture.image.height * 4 * (texture.generateMipmaps ? 1.33 : 1);
-  return Math.ceil(imageBytes);
+function getCanvasSizeBytes(canvas, useMipmaps) {
+  return Math.ceil(canvas.width * canvas.height * 4 * (useMipmaps ? 1.33 : 1));
 }
 const logger$8 = createLogger("line");
 class LineSystem extends RenderableSystem {
@@ -2082,6 +2095,7 @@ class MeshSystem extends RenderableSystem {
       const key = `${batchedMesh.uuid}-${instanceId}`;
       this.mapInstanceIdToShapeType.set(key, type);
       this.registerDefObject(shapeDef, batchedMesh, instanceId);
+      if (shapeDef.hidden) this.updateDefImpl(shapeDef, batchedMesh, [instanceId]);
     }
     return batchedMesh;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/renderer",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "type": "module",
   "files": [
     "dist"
@@ -14,8 +14,6 @@
     "@types/object-hash": "^3.0.6",
     "@types/three": "^0.174.0",
     "stats-gl": "^3.6.0",
-    "typescript": "^5.2.2",
-    "vite": "^5.2.0",
     "vite-bundle-analyzer": "^1.3.2",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-externalize-deps": "^0.9.0"