minerender 2.1.0-alpha.28 → 2.1.0-alpha.29

package/dist/bundle.js

@@ -67364,7 +67364,7 @@ return ${compiler2.callType("value", tagType)}
     }
     static async getItemModel(key) {
       const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-      const model = await this.PERSISTENT_CACHE.getOrLoad(itemKey.serialize(), async () => {
+      const model = await this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(itemKey.serialize()), async () => {
         const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
         if (!result) return void 0;
         if (result.key.assetType !== "items") return { ...result.asset, key };
@@ -67410,7 +67410,7 @@ return ${compiler2.callType("value", tagType)}
       }
       const keyStr = key.serialize();
       return Caching.rawModelCache.get(keyStr, (k4) => {
-        return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+        return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
           return AssetLoader.get(key, "model" /* MODEL */);
         });
       }).then((asset) => {
@@ -67485,7 +67485,7 @@ return ${compiler2.callType("value", tagType)}
       }
       const keyStr = key.serialize();
       return Caching.blockStateCache.get(keyStr, (k4) => {
-        return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+        return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
           return AssetLoader.get(key, "blockstate" /* BLOCKSTATE */);
         });
       }).then((asset) => {
@@ -67539,6 +67539,14 @@ return ${compiler2.callType("value", tagType)}
   var AssetSource = class {
     constructor() {
     }
+    /**
+     * Identifies this source's content across sessions for persistent caching. Sources that
+     * cannot tell whether their content changed (an unnamed archive, for example) return
+     * undefined, which keeps their results out of long-lived caches.
+     */
+    get cacheId() {
+      return void 0;
+    }
   };
   var AssetLoadError = class extends Error {
     constructor(source, key, path, cause) {
@@ -67800,6 +67808,9 @@ return ${compiler2.callType("value", tagType)}
     get root() {
       return this._root;
     }
+    get cacheId() {
+      return `hosted:${this._root}`;
+    }
     get options() {
       return this._options;
     }
@@ -77324,9 +77335,10 @@ return ${compiler2.callType("value", tagType)}
 
   // src/assets/source/archive/BrowserArchiveProxy.ts
   var BrowserArchiveProxy = class {
-    constructor(blob) {
+    constructor(blob, id) {
       this._blob = blob;
       this._reader = new ZipReader(new BlobReader(this._blob));
+      this.id = id ?? (typeof File !== "undefined" && blob instanceof File ? `${blob.name}:${blob.size}:${blob.lastModified}` : void 0);
     }
     async getEntries() {
       return (await this._reader.getEntries()).map((e6) => {
@@ -77351,6 +77363,10 @@ return ${compiler2.callType("value", tagType)}
     static blob(blob) {
       return new _ArchiveAssetSource(new BrowserArchiveProxy(blob));
     }
+    get cacheId() {
+      const id = this._archiveProxy.id;
+      return id === void 0 ? void 0 : `archive:${id}`;
+    }
     async getEntries() {
       return this._archiveProxy.getEntries();
     }
@@ -77403,6 +77419,7 @@ return ${compiler2.callType("value", tagType)}
 
   // src/assets/AssetLoader.ts
   var p7 = prefix("AssetLoader");
+  var FALLBACK_ROOT = "https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master";
   var _AssetLoader = class _AssetLoader {
     static get version() {
       return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
@@ -77418,6 +77435,28 @@ return ${compiler2.callType("value", tagType)}
       }
       Caching.clear();
     }
+    /**
+     * Scope for persistent cache keys. Empty with only the default vanilla sources, so their
+     * entries stay valid across sessions; otherwise it names every added source (resource packs,
+     * mirrors) so their results never masquerade as vanilla assets after a reload.
+     */
+    static get persistentScope() {
+      const parts = [];
+      for (const { key, source } of this._SOURCES) {
+        const id = source.cacheId;
+        if (key === "mcassets" && id === `hosted:${this.ROOT}`) continue;
+        if (key === "mcassets-fallback" && id === `hosted:${FALLBACK_ROOT}`) continue;
+        if (id === void 0) return this.SESSION_SCOPE;
+        parts.push(`${key}=${id}`);
+      }
+      return parts.join("|");
+    }
+    /** Prefixes a persistent cache key with the current source scope. */
+    static persistentKey(key) {
+      const scope = this.persistentScope;
+      return scope ? `${scope}
+${key}` : key;
+    }
     static addSource(key, source, override = true) {
       if (override) {
         const existing = this.removeSource(key);
@@ -77479,7 +77518,9 @@ return ${compiler2.callType("value", tagType)}
   };
   _AssetLoader.ROOT = DEFAULT_ROOT;
   _AssetLoader._SOURCES = [];
-  _AssetLoader.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
+  /** Used when a registered source cannot identify its content, so nothing persists past this session. */
+  _AssetLoader.SESSION_SCOPE = `session:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  _AssetLoader.addSource("mcassets-fallback", new HostedAssetSource(FALLBACK_ROOT, { retryDefaults: false }));
   _AssetLoader.addSource("mcassets", new HostedAssetSource(_AssetLoader.ROOT, { retryDefaults: false }));
   var AssetLoader = _AssetLoader;
 
@@ -77522,7 +77563,7 @@ return ${compiler2.callType("value", tagType)}
       }
       const keyStr = key.serialize();
       return Caching.textureMetaCache.get(keyStr, (k4) => {
-        return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, (k1) => {
+        return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
           return AssetLoader.get(key, "meta" /* META */).then((asset) => {
             if (asset)
               asset.key = key;
@@ -80375,7 +80416,9 @@ return ${compiler2.callType("value", tagType)}
       if (typeof variant.y !== "undefined") {
         rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
       }
-      const model = await Models.getMerged(AssetKey.parse("models", variant.model));
+      const modelKey = AssetKey.parse("models", variant.model);
+      modelKey.root = this.blockState.key?.root;
+      const model = await Models.getMerged(modelKey);
       const options = {
         ...this.options,
         tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
@@ -81210,56 +81253,12 @@ return ${compiler2.callType("value", tagType)}
       }
     },
     cape: {
-      //TODO
-      east: {
-        uv: [
-          0,
-          36,
-          4,
-          48
-        ]
-      },
-      west: {
-        uv: [
-          8,
-          36,
-          12,
-          48
-        ]
-      },
-      north: {
-        uv: [
-          4,
-          36,
-          8,
-          48
-        ]
-      },
-      south: {
-        uv: [
-          12,
-          36,
-          16,
-          48
-        ]
-      },
-      up: {
-        uv: [
-          4,
-          32,
-          8,
-          36
-        ]
-      },
-      down: {
-        uv: [
-          8,
-          32,
-          12,
-          36
-        ],
-        rotation: 180
-      }
+      east: { uv: [0, 1, 1, 17] },
+      west: { uv: [11, 1, 12, 17] },
+      north: { uv: [1, 1, 11, 17] },
+      south: { uv: [12, 1, 22, 17] },
+      up: { uv: [11, 1, 1, 0] },
+      down: { uv: [21, 0, 11, 1] }
     }
   };
   var classicSkinTextureCoordinates = {
@@ -81363,14 +81362,27 @@ return ${compiler2.callType("value", tagType)}
       const key = `skin:${serializeImageKey({ src })}:${isLegacy}`;
       const material = Caching.materialCache.get(key, () => {
         const pixels = isLegacy ? this.normalizeLegacy(image, scale) : new Uint8Array(image.data);
-        const texture = Textures.initTextureProps(new DataTexture(pixels, image.width, image.width));
-        texture.colorSpace = SRGBColorSpace;
-        texture.flipY = true;
-        texture.needsUpdate = true;
-        return new MeshBasicMaterial({ map: texture, transparent: true, side: DoubleSide, alphaTest: 0.5 });
+        return this.createMaterial(pixels, image.width, image.width);
       });
       return { material, slim, legacy: isLegacy };
     }
+    static async getCape(src) {
+      const image = await ImageLoader.getData(src);
+      const scale = image.width / 64;
+      if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width / 2) {
+        throw new MineRenderError(`Invalid cape dimensions ${image.width}x${image.height}; expected 64x32 or an integer-scaled equivalent`);
+      }
+      return Caching.materialCache.get(`cape:${serializeImageKey({ src })}`, () => {
+        return this.createMaterial(new Uint8Array(image.data), image.width, image.height, false);
+      });
+    }
+    static createMaterial(pixels, width, height, transparent = true) {
+      const texture = Textures.initTextureProps(new DataTexture(pixels, width, height));
+      texture.colorSpace = SRGBColorSpace;
+      texture.flipY = true;
+      texture.needsUpdate = true;
+      return new MeshBasicMaterial({ map: texture, transparent, side: transparent ? DoubleSide : FrontSide, alphaTest: transparent ? 0.5 : 0 });
+    }
     static isSlim(image, scale) {
       for (const [x4, y5] of [[46, 52], [54, 20]]) {
         for (let row = y5 * scale; row < (y5 + 12) * scale; row++) {
@@ -81433,6 +81445,7 @@ return ${compiler2.callType("value", tagType)}
       this.slim = false;
       this.detectedSlim = false;
       this.skinLoad = 0;
+      this.capeLoad = 0;
       this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
       this.slim = this.options.slim ?? false;
     }
@@ -81502,6 +81515,7 @@ return ${compiler2.callType("value", tagType)}
       this.detectedSlim = texture.slim;
       this.updateSlim(this.options.slim ?? this.detectedSlim);
       for (const part of SKIN_PARTS) {
+        if (part === "cape" /* CAPE */) continue;
         const mesh = this.getMeshByName(part);
         if (mesh) {
           mesh.material = texture.material;
@@ -81509,7 +81523,34 @@ return ${compiler2.callType("value", tagType)}
       }
       this.notifyDirty();
     }
-    //TODO: cape
+    /** Load a vanilla cape texture, or pass undefined to remove the cape. */
+    async setCapeTexture(src) {
+      const load = ++this.capeLoad;
+      if (src === void 0) {
+        const group = this.getGroupByName("cape" /* CAPE */);
+        if (group) this.remove(group);
+        this.notifyDirty();
+        return;
+      }
+      const material = await SkinTextures.getCape(src);
+      if (load !== this.capeLoad) return;
+      const mesh = this.getMeshByName("cape" /* CAPE */);
+      if (mesh) {
+        mesh.material = material;
+      } else {
+        const group = this.createAndAddGroup("cape" /* CAPE */, 0, 24, 2);
+        group.rotation.set(toRadians(-6), Math.PI, 0);
+        const geometry = this._getBoxGeometryFromDimensions(
+          classicSkinGeometries.cape,
+          classicSkinTextureCoordinates.cape,
+          [64, 32],
+          [64, 32]
+        );
+        const cape = this.createAndAddMesh("cape" /* CAPE */, group, geometry, material);
+        cape.position.set(0, -8, -0.5);
+      }
+      this.notifyDirty();
+    }
     /** Select the arm model, or pass undefined to use texture detection. */
     setSlim(slim) {
       this.options.slim = slim;
@@ -81537,6 +81578,7 @@ return ${compiler2.callType("value", tagType)}
     }
     dispose() {
       this.skinLoad++;
+      this.capeLoad++;
       super.dispose();
     }
     //TODO: layer toggles