minerender 2.1.0-alpha.146 → 2.1.0-alpha.147

package/dist/browser/index.js

@@ -386,6 +386,8 @@ var init_Caching = __esm({
         };
       }
     };
+    /** Cached in place of a missing asset. The caches drop `undefined` results, which would request the asset again. */
+    _Caching.MISSING = false;
     _Caching._generation = 0;
     _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();
@@ -2321,15 +2323,21 @@ var init_ModelTextures = __esm({
           key.extension += ".mcmeta";
         }
         const keyStr = key.serialize();
-        return Caching.textureMetaCache.get(keyStr, (k) => {
-          return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
-            return AssetLoader.get(key, "meta" /* META */).then((asset2) => {
-              if (asset2)
-                asset2.key = key;
-              return asset2;
-            });
+        const meta = await Caching.textureMetaCache.get(keyStr, (k) => {
+          return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), async (k1) => {
+            if (AssetLoader.persistentScope === "") {
+              const path = key.getFullPath();
+              const slash = path.lastIndexOf("/");
+              const listKey = new AssetKey(key.namespace, `${path.slice(0, slash + 1)}_list`, "textures", void 0, "assets", ".json", key.root);
+              const list2 = await Caching.listAssetCache.get(listKey.serialize(), () => AssetLoader.get(listKey, "list" /* LIST */)).catch(() => void 0);
+              if (list2 && !list2.files.includes(`${path.slice(slash + 1)}${key.extension}`)) return Caching.MISSING;
+            }
+            const asset2 = await AssetLoader.get(key, "meta" /* META */);
+            if (asset2) asset2.key = key;
+            return asset2 ?? Caching.MISSING;
           });
         });
+        return meta === Caching.MISSING ? void 0 : meta;
       }
       /** Clears persisted texture metadata. Use {@link Caching.clear} to discard in-memory textures and metadata. */
       static async clearCache() {
@@ -4558,26 +4566,27 @@ var init_Entities = __esm({
         const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
         const root = isAssetKey(modelKey) ? modelKey.root : void 0;
         const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", root);
-        return Caching.entityTextureCache.get(key.serialize(), async () => {
+        const texture = await Caching.entityTextureCache.get(key.serialize(), async () => {
           const name = path.split("/").pop();
           for (const candidate of [path, `${path}/${name}`]) {
-            const texture2 = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png", root);
-            if (await ModelTextures.get(texture2)) return texture2;
+            const texture3 = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png", root);
+            if (await ModelTextures.get(texture3)) return texture3;
           }
           const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json", root);
           const list2 = await AssetLoader.get(listKey, "list" /* LIST */);
           const files = list2?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
           const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
-          if (!file) return void 0;
+          if (!file) return Caching.MISSING;
           const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json", root);
           const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
           const assets = variant?.assets;
           const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
-          if (typeof textureId !== "string") return void 0;
-          const texture = AssetKey.parse("textures", textureId);
-          texture.root = root;
-          return texture;
+          if (typeof textureId !== "string") return Caching.MISSING;
+          const texture2 = AssetKey.parse("textures", textureId);
+          texture2.root = root;
+          return texture2;
         });
+        return texture === Caching.MISSING ? void 0 : texture;
       }
       /** @deprecated Use getEntityList(); block entities share the entity dataset. */
       static getBlockList() {
@@ -9368,6 +9377,10 @@ var init_SkinTextures = __esm({
 });
 
 // src/skin/PlayerHeadTextures.ts
+var PlayerHeadTextures_exports = {};
+__export(PlayerHeadTextures_exports, {
+  PlayerHeadTextures: () => PlayerHeadTextures
+});
 var PlayerHeadTextures;
 var init_PlayerHeadTextures = __esm({
   "src/skin/PlayerHeadTextures.ts"() {
@@ -11093,17 +11106,25 @@ var init_BlockObject = __esm({
         if (!key || this.options.displayPosition) return false;
         const generation = this._entityGeneration;
         const created = [];
+        const placement = new import_three34.Matrix4();
         let resolved;
         try {
           resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
           if (!resolved) return false;
+          BlockEntities.matrix(resolved, placement);
           for (const part of resolved.parts) {
             const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
-            const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            let texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            if (part.textureLocation === void 0 && namespace === "minecraft" && path === "player_head") {
+              const { PlayerHeadTextures: PlayerHeadTextures2 } = await Promise.resolve().then(() => (init_PlayerHeadTextures(), PlayerHeadTextures_exports));
+              texture = (await PlayerHeadTextures2.get(void 0, key.root)).texture;
+            }
             if (texture) texture.root = key.root;
             const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
             if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
-            created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+            const object4 = await this.scene.addEntity(entity, { wireframe: this.options.wireframe });
+            this.placeEntity(object4, placement);
+            created.push(object4);
           }
         } catch (error) {
           log17.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
@@ -11114,18 +11135,21 @@ var init_BlockObject = __esm({
           this.removeEntities(created);
           return true;
         }
-        BlockEntities.matrix(resolved, this._entityPlacement);
+        this._entityPlacement.copy(placement);
         this._entities = created;
         this.placeEntities();
         this.setVisible(this.visible);
         return true;
       }
       placeEntities() {
-        const matrix = new import_three34.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
         for (const entity of this._entities) {
-          matrix.decompose(entity.position, entity.quaternion, entity.scale);
+          this.placeEntity(entity, this._entityPlacement);
         }
       }
+      placeEntity(entity, placement) {
+        const matrix = new import_three34.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(placement);
+        matrix.decompose(entity.position, entity.quaternion, entity.scale);
+      }
       get isOccluding() {
         if (!this.visible) {
           return false;