minerender 2.1.0-alpha.7 → 2.1.0-alpha.9

package/dist/bundle.js

@@ -38,14 +38,6 @@ var MineRender = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __decorateClass = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-    for (var i4 = decorators.length - 1, decorator; i4 >= 0; i4--)
-      if (decorator = decorators[i4])
-        result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-    if (kind && result) __defProp(target, key, result);
-    return result;
-  };
 
   // ../../node_modules/esbuild-plugin-polyfill-node/polyfills/__dirname.js
   var init_dirname = __esm({
@@ -47262,11 +47254,14 @@ return ${compiler2.callType("value", tagType)}
     static open(name2) {
       return Env.provider.openCache(name2, _PersistentCache.VERSION);
     }
+    /** Loads a missing entry and stores only non-nullish results. */
     async getOrLoad(key, loader) {
       let v5 = await this.get(key);
       if (typeof v5 === "undefined" || v5 === null) {
         v5 = await loader(key);
-        await this.put(key, v5);
+        if (typeof v5 !== "undefined" && v5 !== null) {
+          await this.put(key, v5);
+        }
       }
       return v5;
     }
@@ -68077,7 +68072,10 @@ return ${compiler2.callType("value", tagType)}
   init_process2();
 
   // src/cache/Caching.ts
-  var Caching = class {
+  var _Caching = class _Caching {
+    static createAssetCache() {
+      return Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+    }
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     static get all() {
       return [
@@ -68094,7 +68092,10 @@ return ${compiler2.callType("value", tagType)}
         this.rawModelCache,
         this.mergedModelCache,
         this.modelTextureAtlasCache,
-        this.blockStateCache
+        this.blockStateCache,
+        this.listAssetCache,
+        this.defaultBlockStatesCache,
+        this.entityModelsCache
       ];
     }
     static clear() {
@@ -68120,20 +68121,24 @@ return ${compiler2.callType("value", tagType)}
       };
     }
   };
-  Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
-  Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
-  Caching.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
+  _Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
+  _Caching.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.listAssetCache = _Caching.createAssetCache();
+  _Caching.defaultBlockStatesCache = _Caching.createAssetCache();
+  _Caching.entityModelsCache = _Caching.createAssetCache();
+  var Caching = _Caching;
 
   // src/Geometries.ts
   var Geometries = class _Geometries {
@@ -68483,29 +68488,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 +68533,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 +68549,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 +68575,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 +68597,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 +68622,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 +68656,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 +68804,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);
       });
@@ -68974,95 +69001,6 @@ return ${compiler2.callType("value", tagType)}
     }
   };
 
-  // ../../node_modules/typescript-memoize/dist/es2015/memoize-decorator.js
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  function Memoize(args) {
-    let hashFunction;
-    let duration;
-    let tags;
-    if (typeof args === "object") {
-      hashFunction = args.hashFunction;
-      duration = args.expiring;
-      tags = args.tags;
-    } else {
-      hashFunction = args;
-    }
-    return (target, propertyKey, descriptor) => {
-      if (descriptor.value != null) {
-        descriptor.value = getNewFunction(descriptor.value, hashFunction, duration, tags);
-      } else if (descriptor.get != null) {
-        descriptor.get = getNewFunction(descriptor.get, hashFunction, duration, tags);
-      } else {
-        throw "Only put a Memoize() decorator on a method or get accessor.";
-      }
-    };
-  }
-  var clearCacheTagsMap = /* @__PURE__ */ new Map();
-  function getNewFunction(originalMethod, hashFunction, duration = 0, tags) {
-    const propMapName = Symbol(`__memoized_map__`);
-    return function(...args) {
-      let returnedValue;
-      if (!this.hasOwnProperty(propMapName)) {
-        Object.defineProperty(this, propMapName, {
-          configurable: false,
-          enumerable: false,
-          writable: false,
-          value: /* @__PURE__ */ new Map()
-        });
-      }
-      let myMap = this[propMapName];
-      if (Array.isArray(tags)) {
-        for (const tag of tags) {
-          if (clearCacheTagsMap.has(tag)) {
-            clearCacheTagsMap.get(tag).push(myMap);
-          } else {
-            clearCacheTagsMap.set(tag, [myMap]);
-          }
-        }
-      }
-      if (hashFunction || args.length > 0 || duration > 0) {
-        let hashKey;
-        if (hashFunction === true) {
-          hashKey = args.map((a4) => a4.toString()).join("!");
-        } else if (hashFunction) {
-          hashKey = hashFunction.apply(this, args);
-        } else {
-          hashKey = args[0];
-        }
-        const timestampKey = `${hashKey}__timestamp`;
-        let isExpired = false;
-        if (duration > 0) {
-          if (!myMap.has(timestampKey)) {
-            isExpired = true;
-          } else {
-            let timestamp = myMap.get(timestampKey);
-            isExpired = Date.now() - timestamp > duration;
-          }
-        }
-        if (myMap.has(hashKey) && !isExpired) {
-          returnedValue = myMap.get(hashKey);
-        } else {
-          returnedValue = originalMethod.apply(this, args);
-          myMap.set(hashKey, returnedValue);
-          if (duration > 0) {
-            myMap.set(timestampKey, Date.now());
-          }
-        }
-      } else {
-        const hashKey = this;
-        if (myMap.has(hashKey)) {
-          returnedValue = myMap.get(hashKey);
-        } else {
-          returnedValue = originalMethod.apply(this, args);
-          myMap.set(hashKey, returnedValue);
-        }
-      }
-      return returnedValue;
-    };
-  }
-
   // src/assets/source/parser/AssetParsers.ts
   init_dirname();
   init_buffer2();
@@ -69079,14 +69017,14 @@ return ${compiler2.callType("value", tagType)}
   })(AssetParser || {});
 
   // src/assets/Models.ts
-  var _Models = class _Models {
+  var Models = class _Models {
     // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
     // the library, and would require an EnvProvider before any entry has had a chance to register
     static get PERSISTENT_CACHE() {
       return this._persistentCache ?? (this._persistentCache = PersistentCache.open("minerender-models"));
     }
     static async getItemList() {
-      return AssetLoader.get(new AssetKey(
+      const key = new AssetKey(
         DEFAULT_NAMESPACE,
         "_list",
         "models",
@@ -69094,7 +69032,10 @@ return ${compiler2.callType("value", tagType)}
         "assets",
         ".json",
         DEFAULT_ROOT
-      ), "list" /* LIST */).then((r5) => r5?.files ?? []);
+      );
+      return Caching.listAssetCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "list" /* LIST */);
+      }).then((r5) => r5?.files ?? []);
     }
     static async loadAndMerge(key) {
       const model = await this.getRaw(key);
@@ -69141,10 +69082,6 @@ return ${compiler2.callType("value", tagType)}
       return this.PERSISTENT_CACHE.clear();
     }
   };
-  __decorateClass([
-    Memoize()
-  ], _Models, "getItemList", 1);
-  var Models = _Models;
 
   // src/assets/BlockStates.ts
   init_dirname();
@@ -69154,8 +69091,9 @@ return ${compiler2.callType("value", tagType)}
     static get PERSISTENT_CACHE() {
       return this._persistentCache ?? (this._persistentCache = PersistentCache.open("minerender-blockstates"));
     }
+    // BlockState names are hardcoded
     static async getList() {
-      return AssetLoader.get(new AssetKey(
+      const key = new AssetKey(
         DEFAULT_NAMESPACE,
         "_list",
         "blockstates",
@@ -69163,11 +69101,16 @@ return ${compiler2.callType("value", tagType)}
         "assets",
         ".json",
         DEFAULT_ROOT
-      ), "list" /* LIST */).then((r5) => r5?.files ?? []);
+      );
+      return Caching.listAssetCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "list" /* LIST */);
+      }).then((r5) => r5?.files ?? []);
     }
     static async getDefaultStates() {
       const key = AssetKey.parse("blockstates", "minerender:defaultBlockStates");
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.defaultBlockStatesCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     static async getDefaultState(key) {
       const defaultStates = await this.getDefaultStates();
@@ -69206,12 +69149,6 @@ return ${compiler2.callType("value", tagType)}
       await this.PERSISTENT_CACHE.clear();
     }
   };
-  __decorateClass([
-    Memoize()
-  ], BlockStates, "getList", 1);
-  __decorateClass([
-    Memoize()
-  ], BlockStates, "getDefaultStates", 1);
   var DefaultBlockStates = class {
   };
 
@@ -79068,11 +79005,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();
@@ -79798,12 +79745,16 @@ return ${compiler2.callType("value", tagType)}
     static async getBlockEntityModels() {
       const key = AssetKey.parse("models", "minerender:blockEntityModels");
       console.log(key);
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.entityModelsCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     static async getEntityModels() {
       const key = AssetKey.parse("models", "minerender:entityModels");
       console.log(key);
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.entityModelsCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     // BlockEntity names are hardcoded
     static async getBlockList() {
@@ -79849,12 +79800,6 @@ return ${compiler2.callType("value", tagType)}
       };
     }
   };
-  __decorateClass([
-    Memoize()
-  ], Entities, "getBlockEntityModels", 1);
-  __decorateClass([
-    Memoize()
-  ], Entities, "getEntityModels", 1);
   var EntityModels = class {
   };
   var BlockEntityModels = class {
@@ -80367,8 +80312,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 +80321,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 +80357,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, {});