minerender 2.1.0-alpha.7 → 2.1.0-alpha.8

package/dist/bundle.js

@@ -68483,29 +68483,41 @@ return ${compiler2.callType("value", tagType)}
     static async loadAsync(src) {
       return new Promise((resolve, reject) => {
         const image = this._createImage();
-        image.src = src;
         image.onload = () => resolve(image);
-        image.onerror = (err) => reject(err);
+        image.onerror = (err) => reject(err instanceof Error ? err : new Error("Failed to decode image"));
+        image.src = src;
       });
     }
     static loadElement(src, onload, onerr) {
       const image = this._createImage();
-      image.src = src;
       if (onload)
         image.onload = onload;
       if (onerr)
         image.onerror = onerr;
+      image.src = src;
       return image;
     }
     static async loadData(src) {
       console.debug(p2, "loadData", src);
-      return await this.infoToData(await this.getInfo(src));
+      const image = await this.loadCanvasData(src);
+      return image.data.getImageData(0, 0, image.width, image.height);
     }
     static async loadCanvasData(src) {
-      return await this.infoToCanvasData(await this.getInfo(src));
+      const keyStr = serializeImageKey({ src });
+      const info = this.getInfo(src);
+      const cached = Caching.rawImageCache.getIfPresent(keyStr);
+      try {
+        return await this.infoToCanvasData(await info);
+      } catch (err) {
+        if (cached && Caching.rawImageCache.getIfPresent(keyStr) === cached) {
+          Caching.rawImageCache.invalidate(keyStr);
+        }
+        throw err;
+      }
     }
     static async infoToCanvasData(info) {
-      const image = await _ImageLoader.loadAsync(info.src);
+      const type = info.type === "jpg" ? "jpeg" : info.type ?? "png";
+      const image = await _ImageLoader.loadAsync(`data:image/${type};base64,${info.data.toString("base64")}`);
       const canvas = createCanvas(info.width, info.height);
       const context = canvas.getContext("2d");
       context.drawImage(image, 0, 0);
@@ -68516,11 +68528,8 @@ return ${compiler2.callType("value", tagType)}
       };
     }
     static async infoToData(info) {
-      const image = await _ImageLoader.loadAsync(info.src);
-      const canvas = createCanvas(info.width, info.height);
-      const context = canvas.getContext("2d");
-      context.drawImage(image, 0, 0);
-      return context.getImageData(0, 0, canvas.width, canvas.height);
+      const image = await this.infoToCanvasData(info);
+      return image.data.getImageData(0, 0, image.width, image.height);
     }
     static async getData(src) {
       const keyStr = serializeImageKey({ src });
@@ -68535,13 +68544,16 @@ return ${compiler2.callType("value", tagType)}
       });
     }
     static async processResponse(response) {
-      const src = response.config.url;
+      const src = response.config?.url;
       const data = Buffer.from(response.data);
       const { width, height, type } = Env.provider.imageSize(data);
+      if (!width || !height) {
+        throw new Error("Invalid or unsupported image dimensions");
+      }
       return {
         src,
-        width: width || 0,
-        height: height || 0,
+        width,
+        height,
         type,
         data
       };
@@ -68558,15 +68570,7 @@ return ${compiler2.callType("value", tagType)}
       return Requests.genericRequest({
         url: src,
         responseType: "arraybuffer"
-      }).then(this.processResponse).catch((err) => {
-        return {
-          src,
-          width: 0,
-          height: 0,
-          type: void 0,
-          data: Buffer.from([0])
-        };
-      });
+      }).then(this.processResponse);
     }
     static async getInfo(src) {
       const keyStr = serializeImageKey({ src });
@@ -68588,16 +68592,22 @@ return ${compiler2.callType("value", tagType)}
 
   // src/texture/TextureLoader.ts
   var TextureLoader = class {
+    /** Reports whether image loading failed, so cached textures can be retried. */
+    static hasFailed(texture) {
+      return this.failedTextures.has(texture);
+    }
     static createTexture() {
       return new Texture();
     }
     static loadInBackground(src, format2 = RGBAFormat, rotation = 0) {
       const texture = this.createTexture();
       texture.colorSpace = SRGBColorSpace;
-      const image = ImageLoader.loadElement(src);
-      image.onload = function() {
+      const image = ImageLoader.loadElement(src, () => {
         texture.needsUpdate = true;
-      };
+      }, (error) => {
+        this.failedTextures.add(texture);
+        console.warn("Failed to load texture", src, error);
+      });
       texture.image = image;
       texture.format = format2;
       texture.rotation = rotation;
@@ -68607,14 +68617,18 @@ return ${compiler2.callType("value", tagType)}
       const texture = new Texture();
       texture.colorSpace = SRGBColorSpace;
       ImageLoader.getData(src).then((image) => {
-        texture.needsUpdate = true;
         texture.image = image;
+        texture.needsUpdate = true;
+      }).catch((error) => {
+        this.failedTextures.add(texture);
+        console.warn("Failed to load texture", src, error);
       });
       texture.format = format2;
       texture.rotation = rotation;
       return Textures.initTextureProps(texture);
     }
   };
+  TextureLoader.failedTextures = /* @__PURE__ */ new WeakSet();
 
   // src/texture/Textures.ts
   var Textures = class _Textures {
@@ -68637,6 +68651,10 @@ return ${compiler2.callType("value", tagType)}
     }
     static getImage(key) {
       const keyStr = serializeTextureKey(key);
+      const cached = Caching.textureCache.peek(keyStr);
+      if (cached && TextureLoader.hasFailed(cached)) {
+        Caching.textureCache.invalidate(keyStr);
+      }
       return Caching.textureCache.get(keyStr, (k4) => {
         return _Textures.createImage(key);
       });
@@ -68781,6 +68799,10 @@ return ${compiler2.callType("value", tagType)}
     }
     static getImage(key) {
       const keyStr = serializeMaterialKey(key);
+      const map = Caching.materialCache.peek(keyStr)?.map;
+      if (map && TextureLoader.hasFailed(map)) {
+        Caching.materialCache.invalidate(keyStr);
+      }
       return Caching.materialCache.get(keyStr, (k4) => {
         return _Materials.createImage(key);
       });
@@ -79068,11 +79090,21 @@ return ${compiler2.callType("value", tagType)}
       return this._persistentMetaCache ?? (this._persistentMetaCache = PersistentCache.open("minerender-texturemeta"));
     }
     static async get(key) {
-      const asset = await this.preload(key);
-      if (asset) {
-        return ImageLoader.infoToCanvasData(asset);
+      const keyStr = key.serialize();
+      const pending = this.preload(key);
+      const cached = Caching.textureAssetCache.getIfPresent(keyStr);
+      try {
+        const asset = await pending;
+        if (asset) {
+          return await ImageLoader.infoToCanvasData(asset);
+        }
+        return void 0;
+      } catch (err) {
+        if (cached && Caching.textureAssetCache.getIfPresent(keyStr) === cached) {
+          Caching.textureAssetCache.invalidate(keyStr);
+        }
+        throw err;
       }
-      return void 0;
     }
     static async preload(key) {
       const keyStr = key.serialize();
@@ -80367,8 +80399,8 @@ return ${compiler2.callType("value", tagType)}
     dispose() {
       super.dispose();
     }
-    async loadTextures() {
-      this.imageData = await ModelTextures.get(new AssetKey(
+    get textureKey() {
+      return new AssetKey(
         this.entity.key?.namespace ?? DEFAULT_NAMESPACE,
         this.entity.key.path,
         //TODO: texture may differ from entity name; most of them are in subdirectories for multiple variants etc.
@@ -80376,7 +80408,10 @@ return ${compiler2.callType("value", tagType)}
         "entity",
         "assets",
         ".png"
-      ));
+      );
+    }
+    async loadTextures() {
+      this.imageData = await ModelTextures.get(this.textureKey);
     }
     //TODO: abstract this, since extracted model data can be used for entities, blocks, players
     createMeshes(force = false) {
@@ -80409,20 +80444,23 @@ return ${compiler2.callType("value", tagType)}
       this.meshesCreated = true;
     }
     async applyTextures() {
-      const textureAsset = await ModelTextures.preload(new AssetKey(
-        this.entity.key?.namespace ?? DEFAULT_NAMESPACE,
-        this.entity.key.path,
-        "textures",
-        "entity",
-        "assets",
-        ".png"
-      ));
-      if (textureAsset) {
-        let mat = Materials.getImage({ texture: { src: textureAsset.src } });
-        this.iterateAllMeshes((mesh) => {
-          mesh.material = mat;
-        });
-      }
+      const assetKeyStr = this.textureKey.serialize();
+      const keyStr = `entity:${assetKeyStr}`;
+      let mat = Caching.materialCache.getIfPresent(keyStr);
+      if (!mat) {
+        const pending = this.loadTextures();
+        const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+        await pending;
+        if (!this.imageData) return;
+        const canvas = this.imageData.data.canvas;
+        const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
+        mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+        this.imageData = void 0;
+      }
+      this.iterateAllMeshes((mesh) => {
+        mesh.material = mat;
+      });
+      this.notifyDirty();
     }
   };
   EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, {});