minerender 2.1.0-alpha.145 → 2.1.0-alpha.147

package/dist/node/index.mjs

@@ -240,6 +240,10 @@ var Caching;
 var init_Caching = __esm({
   "src/cache/Caching.ts"() {
     Caching = class _Caching {
+      static {
+        /** Cached in place of a missing asset. The caches drop `undefined` results, which would request the asset again. */
+        this.MISSING = false;
+      }
       static {
         this._generation = 0;
       }
@@ -2405,15 +2409,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() {
@@ -4659,26 +4669,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() {
@@ -9505,6 +9516,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"() {
@@ -11235,17 +11250,25 @@ var init_BlockObject = __esm({
         if (!key || this.options.displayPosition) return false;
         const generation = this._entityGeneration;
         const created = [];
+        const placement = new Matrix410();
         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) {
           log15.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
@@ -11256,18 +11279,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 Matrix410().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 Matrix410().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;
@@ -11561,6 +11587,7 @@ init_PersistentCache();
 var NodeCache = class extends PersistentCache {
   constructor(backing) {
     super(backing);
+    this.pendingWrites = /* @__PURE__ */ new Map();
   }
   ready() {
     return this.initialized ??= this.backing.init();
@@ -11571,7 +11598,14 @@ var NodeCache = class extends PersistentCache {
   }
   async put(key, value) {
     await this.ready();
-    return this.backing.setItem(key, value).then((res) => res.content);
+    const previous = this.pendingWrites.get(key);
+    const write = (previous ? previous.catch(() => void 0) : Promise.resolve()).then(() => this.backing.setItem(key, value)).then(() => value);
+    this.pendingWrites.set(key, write);
+    try {
+      return await write;
+    } finally {
+      if (this.pendingWrites.get(key) === write) this.pendingWrites.delete(key);
+    }
   }
   async delete(key) {
     await this.ready();
@@ -11617,7 +11651,10 @@ var NodeEnv = class {
   openCache(name, version2) {
     return new NodeCache(NodePersist.create({
       dir: name + version2,
-      encoding: "utf8"
+      encoding: "utf8",
+      // node-persist's unref'd one-second write queue delays loads and lets Node exit before writes finish.
+      // NodeCache serializes writes to each key while allowing different files to write concurrently.
+      writeQueue: false
     }));
   }
 };