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

package/dist/browser/index.d.mts

@@ -64,6 +64,7 @@ declare abstract class PersistentCache<B = unknown> {
     static open(name: string): PersistentCache;
     protected constructor(backing: B);
     abstract get<T>(key: string): Promise<T>;
+    /** Loads a missing entry and stores only non-nullish results. */
     getOrLoad<T>(key: string, loader: (key: string) => Promise<T>): Promise<T>;
     abstract put<T>(key: string, value: T): Promise<T>;
     abstract delete<T>(key: string): Promise<void>;
@@ -852,6 +853,7 @@ declare class EntityObject extends SceneObject {
     constructor(entity: EntityModel, options?: Partial<EntityObjectOptions>);
     init(): Promise<void>;
     dispose(): void;
+    private get textureKey();
     protected loadTextures(): Promise<void>;
     protected createMeshes(force?: boolean): void;
     protected applyTextures(): Promise<void>;
@@ -1212,6 +1214,10 @@ declare class Caching {
     static readonly mergedModelCache: AsyncLoadingCache<CacheKey, Model>;
     static readonly modelTextureAtlasCache: AsyncLoadingCache<CacheKey, TextureAtlas>;
     static readonly blockStateCache: AsyncLoadingCache<CacheKey, BlockState>;
+    static readonly listAssetCache: AsyncLoadingCache<CacheKey, ListAsset>;
+    static readonly defaultBlockStatesCache: AsyncLoadingCache<CacheKey, DefaultBlockStates>;
+    static readonly entityModelsCache: AsyncLoadingCache<CacheKey, EntityModels>;
+    private static createAssetCache;
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     private static get all();
     static clear(): void;
@@ -1511,6 +1517,9 @@ declare class Skins {
 }
 
 declare class TextureLoader {
+    private static readonly failedTextures;
+    /** Reports whether image loading failed, so cached textures can be retried. */
+    static hasFailed(texture: Texture): boolean;
     protected static createTexture(): Texture;
     static loadInBackground(src: string, format?: PixelFormat, rotation?: number): Texture;
     static load(src: string, format?: PixelFormat, rotation?: number): Texture;
@@ -1620,7 +1629,7 @@ declare class BrowserCache extends PersistentCache<LocalForage> {
  *
  * `image-size` pulls in `fs`/`path` at module scope, so it can only live in the Node build.
  * Everything MineRender loads is a PNG in practice; GIF and JPEG are handled as a courtesy and
- * anything else falls through to an empty result (callers treat that as 0x0).
+ * anything else falls through to an empty result, which ImageLoader rejects.
  */
 declare function probeImageSize(data: Uint8Array): ImageSizeInfo;
 

package/dist/browser/index.d.ts

@@ -64,6 +64,7 @@ declare abstract class PersistentCache<B = unknown> {
     static open(name: string): PersistentCache;
     protected constructor(backing: B);
     abstract get<T>(key: string): Promise<T>;
+    /** Loads a missing entry and stores only non-nullish results. */
     getOrLoad<T>(key: string, loader: (key: string) => Promise<T>): Promise<T>;
     abstract put<T>(key: string, value: T): Promise<T>;
     abstract delete<T>(key: string): Promise<void>;
@@ -852,6 +853,7 @@ declare class EntityObject extends SceneObject {
     constructor(entity: EntityModel, options?: Partial<EntityObjectOptions>);
     init(): Promise<void>;
     dispose(): void;
+    private get textureKey();
     protected loadTextures(): Promise<void>;
     protected createMeshes(force?: boolean): void;
     protected applyTextures(): Promise<void>;
@@ -1212,6 +1214,10 @@ declare class Caching {
     static readonly mergedModelCache: AsyncLoadingCache<CacheKey, Model>;
     static readonly modelTextureAtlasCache: AsyncLoadingCache<CacheKey, TextureAtlas>;
     static readonly blockStateCache: AsyncLoadingCache<CacheKey, BlockState>;
+    static readonly listAssetCache: AsyncLoadingCache<CacheKey, ListAsset>;
+    static readonly defaultBlockStatesCache: AsyncLoadingCache<CacheKey, DefaultBlockStates>;
+    static readonly entityModelsCache: AsyncLoadingCache<CacheKey, EntityModels>;
+    private static createAssetCache;
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     private static get all();
     static clear(): void;
@@ -1511,6 +1517,9 @@ declare class Skins {
 }
 
 declare class TextureLoader {
+    private static readonly failedTextures;
+    /** Reports whether image loading failed, so cached textures can be retried. */
+    static hasFailed(texture: Texture): boolean;
     protected static createTexture(): Texture;
     static loadInBackground(src: string, format?: PixelFormat, rotation?: number): Texture;
     static load(src: string, format?: PixelFormat, rotation?: number): Texture;
@@ -1620,7 +1629,7 @@ declare class BrowserCache extends PersistentCache<LocalForage> {
  *
  * `image-size` pulls in `fs`/`path` at module scope, so it can only live in the Node build.
  * Everything MineRender loads is a PNG in practice; GIF and JPEG are handled as a courtesy and
- * anything else falls through to an empty result (callers treat that as 0x0).
+ * anything else falls through to an empty result, which ImageLoader rejects.
  */
 declare function probeImageSize(data: Uint8Array): ImageSizeInfo;
 

package/dist/browser/index.js

@@ -28,14 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
 
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
@@ -308,11 +300,14 @@ var _PersistentCache = class _PersistentCache {
   static open(name) {
     return Env.provider.openCache(name, _PersistentCache.VERSION);
   }
+  /** Loads a missing entry and stores only non-nullish results. */
   async getOrLoad(key, loader) {
     let v = await this.get(key);
     if (typeof v === "undefined" || v === null) {
       v = await loader(key);
-      await this.put(key, v);
+      if (typeof v !== "undefined" && v !== null) {
+        await this.put(key, v);
+      }
     }
     return v;
   }
@@ -548,7 +543,10 @@ function serializeMeshKey(key) {
 // src/cache/Caching.ts
 var import_loading_cache = require("@inventivetalent/loading-cache");
 var import_time = require("@inventivetalent/time");
-var Caching = class {
+var _Caching = class _Caching {
+  static createAssetCache() {
+    return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.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 [
@@ -565,7 +563,10 @@ var Caching = class {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache
+      this.blockStateCache,
+      this.listAssetCache,
+      this.defaultBlockStatesCache,
+      this.entityModelsCache
     ];
   }
   static clear() {
@@ -591,20 +592,24 @@ var Caching = class {
     };
   }
 };
-Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
-Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
-Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
+_Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
+_Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.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 {
@@ -912,29 +917,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);
@@ -945,11 +962,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 });
@@ -964,13 +978,16 @@ var ImageLoader = class _ImageLoader {
     });
   }
   static async processResponse(response) {
-    const src = response.config.url;
+    const src = response.config?.url;
     const data = import_buffer.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
     };
@@ -987,15 +1004,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: import_buffer.Buffer.from([0])
-      };
-    });
+    }).then(this.processResponse);
   }
   static async getInfo(src) {
     const keyStr = serializeImageKey({ src });
@@ -1017,16 +1026,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 import_three4.Texture();
   }
   static loadInBackground(src, format = import_three4.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;
@@ -1036,14 +1051,18 @@ var TextureLoader = class {
     const texture = new import_three4.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
 var THREE2 = __toESM(require("three"));
@@ -1067,6 +1086,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);
     });
@@ -1211,6 +1234,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);
     });
@@ -1364,9 +1391,6 @@ var ModelMerger = class {
   }
 };
 
-// src/assets/Models.ts
-var import_typescript_memoize = require("typescript-memoize");
-
 // src/assets/source/parser/AssetParsers.ts
 var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
   AssetParser2["MODEL"] = "model";
@@ -1380,14 +1404,14 @@ var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
 })(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",
@@ -1395,7 +1419,10 @@ var _Models = class _Models {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => r?.files ?? []);
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.files ?? []);
   }
   static async loadAndMerge(key) {
     const model = await this.getRaw(key);
@@ -1442,19 +1469,15 @@ var _Models = class _Models {
     return this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize.Memoize)()
-], _Models, "getItemList", 1);
-var Models = _Models;
 
 // src/assets/BlockStates.ts
-var import_typescript_memoize2 = require("typescript-memoize");
 var BlockStates = class {
   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",
@@ -1462,11 +1485,16 @@ var BlockStates = class {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => r?.files ?? []);
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.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();
@@ -1505,12 +1533,6 @@ var BlockStates = class {
     await this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getList", 1);
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getDefaultStates", 1);
 var DefaultBlockStates = class {
 };
 
@@ -1868,11 +1890,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();
@@ -2550,17 +2582,20 @@ function shutdown() {
 }
 
 // src/assets/Entities.ts
-var import_typescript_memoize3 = require("typescript-memoize");
 var Entities = class {
   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() {
@@ -2606,12 +2641,6 @@ var Entities = class {
     };
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getBlockEntityModels", 1);
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getEntityModels", 1);
 var EntityModels = class {
 };
 var BlockEntityModels = class {
@@ -3063,8 +3092,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.
@@ -3072,7 +3101,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) {
@@ -3105,20 +3137,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, {});