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

package/dist/bundle.js

@@ -35733,6 +35733,8 @@ void main() {
           };
         }
       };
+      /** 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 = 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();
@@ -81427,15 +81429,21 @@ ${key}` : key;
             key.extension += ".mcmeta";
           }
           const keyStr = key.serialize();
-          return Caching.textureMetaCache.get(keyStr, (k4) => {
-            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, (k4) => {
+            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() {
@@ -83736,26 +83744,27 @@ ${key}` : key, async () => {
           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 name2 = path.split("/").pop();
             for (const candidate of [path, `${path}/${name2}`]) {
-              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", `${name2}_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), `${name2}_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() {
@@ -91333,6 +91342,10 @@ ${key}` : key, async () => {
   });
 
   // src/skin/PlayerHeadTextures.ts
+  var PlayerHeadTextures_exports = {};
+  __export(PlayerHeadTextures_exports, {
+    PlayerHeadTextures: () => PlayerHeadTextures
+  });
   var PlayerHeadTextures;
   var init_PlayerHeadTextures = __esm({
     "src/skin/PlayerHeadTextures.ts"() {
@@ -93093,17 +93106,25 @@ ${shader.fragmentShader}`.replace(
           if (!key || this.options.displayPosition) return false;
           const generation = this._entityGeneration;
           const created = [];
+          const placement = new 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 (error2) {
             log19.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error2);
@@ -93114,18 +93135,21 @@ ${shader.fragmentShader}`.replace(
             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 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 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;