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

package/dist/browser/index.mjs

@@ -758,29 +758,41 @@ var ImageLoader = class _ImageLoader {
   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);
@@ -791,11 +803,8 @@ var ImageLoader = class _ImageLoader {
     };
   }
   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 });
@@ -810,13 +819,16 @@ var ImageLoader = class _ImageLoader {
     });
   }
   static async processResponse(response) {
-    const src = response.config.url;
+    const src = response.config?.url;
     const data = Buffer2.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
     };
@@ -833,15 +845,7 @@ var ImageLoader = class _ImageLoader {
     return Requests.genericRequest({
       url: src,
       responseType: "arraybuffer"
-    }).then(this.processResponse).catch((err) => {
-      return {
-        src,
-        width: 0,
-        height: 0,
-        type: void 0,
-        data: Buffer2.from([0])
-      };
-    });
+    }).then(this.processResponse);
   }
   static async getInfo(src) {
     const keyStr = serializeImageKey({ src });
@@ -863,16 +867,22 @@ var ImageLoader = class _ImageLoader {
 
 // 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, format = RGBAFormat, rotation = 0) {
     const texture = this.createTexture();
     texture.colorSpace = THREE.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 = format;
     texture.rotation = rotation;
@@ -882,14 +892,18 @@ var TextureLoader = class {
     const texture = new Texture();
     texture.colorSpace = THREE.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 = format;
     texture.rotation = rotation;
     return Textures.initTextureProps(texture);
   }
 };
+TextureLoader.failedTextures = /* @__PURE__ */ new WeakSet();
 
 // src/texture/Textures.ts
 import * as THREE2 from "three";
@@ -913,6 +927,10 @@ var Textures = class _Textures {
   }
   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, (k) => {
       return _Textures.createImage(key);
     });
@@ -1057,6 +1075,10 @@ var _Materials = class _Materials {
   }
   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, (k) => {
       return _Materials.createImage(key);
     });
@@ -1714,11 +1736,21 @@ var ModelTextures = class {
     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();
@@ -2909,8 +2941,8 @@ var EntityObject = class extends SceneObject {
   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.
@@ -2918,7 +2950,10 @@ var EntityObject = class extends SceneObject {
       "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) {
@@ -2951,20 +2986,23 @@ var EntityObject = class extends SceneObject {
     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, {});