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

package/dist/node/index.mjs

@@ -1319,7 +1319,7 @@ var Models = class _Models {
   }
   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 };
@@ -1365,7 +1365,7 @@ var Models = class _Models {
     }
     const keyStr = key.serialize();
     return Caching.rawModelCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "model" /* MODEL */);
       });
     }).then((asset) => {
@@ -1437,7 +1437,7 @@ var BlockStates = class {
     }
     const keyStr = key.serialize();
     return Caching.blockStateCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "blockstate" /* BLOCKSTATE */);
       });
     }).then((asset) => {
@@ -1483,6 +1483,14 @@ var Assets = class {
 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) {
@@ -1771,6 +1779,9 @@ var HostedAssetSource = class _HostedAssetSource extends AssetSource {
   get root() {
     return this._root;
   }
+  get cacheId() {
+    return `hosted:${this._root}`;
+  }
   get options() {
     return this._options;
   }
@@ -1786,9 +1797,10 @@ var HostedAssetSource = class _HostedAssetSource extends AssetSource {
 // src/assets/source/archive/BrowserArchiveProxy.ts
 import { BlobReader, BlobWriter, ZipReader } from "@zip.js/zip.js";
 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((e) => {
@@ -1813,6 +1825,10 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   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();
   }
@@ -1855,6 +1871,7 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 
 // src/assets/AssetLoader.ts
 var p4 = prefix("AssetLoader");
+var FALLBACK_ROOT = "https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master";
 var AssetLoader = class {
   static {
     this.ROOT = DEFAULT_ROOT;
@@ -1862,6 +1879,10 @@ var AssetLoader = class {
   static {
     this._SOURCES = [];
   }
+  static {
+    /** Used when a registered source cannot identify its content, so nothing persists past this session. */
+    this.SESSION_SCOPE = `session:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
   static get version() {
     return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
   }
@@ -1876,6 +1897,28 @@ var AssetLoader = class {
     }
     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);
@@ -1897,7 +1940,7 @@ var AssetLoader = class {
     return void 0;
   }
   static {
-    this.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
+    this.addSource("mcassets-fallback", new HostedAssetSource(FALLBACK_ROOT, { retryDefaults: false }));
     this.addSource("mcassets", new HostedAssetSource(this.ROOT, { retryDefaults: false }));
   }
   static async getAll(key, parser) {
@@ -1979,7 +2022,7 @@ var ModelTextures = class {
     }
     const keyStr = key.serialize();
     return Caching.textureMetaCache.get(keyStr, (k) => {
-      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;
@@ -4659,7 +4702,9 @@ var BlockObject = class _BlockObject extends SceneObject {
     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,
@@ -5451,56 +5496,12 @@ var baseSkinCoordinates = {
     }
   },
   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 = {
@@ -5583,7 +5584,7 @@ var slimSkinGeometries = {
 var import_ts_deepmerge7 = __toESM(require_dist());
 
 // src/skin/SkinTextures.ts
-import { DataTexture, DoubleSide as DoubleSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace3 } from "three";
+import { DataTexture, DoubleSide as DoubleSide2, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace3 } from "three";
 var SkinTextures = class {
   static async get(src, legacy) {
     const image = await ImageLoader.getData(src);
@@ -5599,14 +5600,27 @@ var SkinTextures = class {
     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 = SRGBColorSpace3;
-      texture.flipY = true;
-      texture.needsUpdate = true;
-      return new MeshBasicMaterial3({ map: texture, transparent: true, side: DoubleSide2, 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 = SRGBColorSpace3;
+    texture.flipY = true;
+    texture.needsUpdate = true;
+    return new MeshBasicMaterial3({ map: texture, transparent, side: transparent ? DoubleSide2 : FrontSide2, alphaTest: transparent ? 0.5 : 0 });
+  }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
       for (let row = y * scale; row < (y + 12) * scale; row++) {
@@ -5669,6 +5683,7 @@ var SkinObject = class extends SceneObject {
     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;
   }
@@ -5738,6 +5753,7 @@ var SkinObject = class extends SceneObject {
     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;
@@ -5745,7 +5761,34 @@ var SkinObject = class extends SceneObject {
     }
     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;
@@ -5773,6 +5816,7 @@ var SkinObject = class extends SceneObject {
   }
   dispose() {
     this.skinLoad++;
+    this.capeLoad++;
     super.dispose();
   }
   //TODO: layer toggles