minerender 2.1.0-alpha.27 → 2.1.0-alpha.29

package/dist/bundle.js

@@ -45411,6 +45411,7 @@ return ${compiler2.callType("value", tagType)}
     SchematicParser: () => SchematicParser,
     SkinObject: () => SkinObject,
     SkinPart: () => SkinPart,
+    SkinTextures: () => SkinTextures,
     Skins: () => Skins,
     StructureParser: () => StructureParser,
     TextureAtlas: () => TextureAtlas,
@@ -63612,6 +63613,16 @@ return ${compiler2.callType("value", tagType)}
       }
     }
   };
+  var DataTexture = class extends Texture {
+    constructor(data = null, width = 1, height = 1, format2, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) {
+      super(null, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+      this.isDataTexture = true;
+      this.image = { data, width, height };
+      this.generateMipmaps = false;
+      this.flipY = false;
+      this.unpackAlignment = 1;
+    }
+  };
   var InstancedBufferAttribute = class extends BufferAttribute {
     constructor(array, itemSize, normalized, meshPerAttribute = 1) {
       super(array, itemSize, normalized);
@@ -67353,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 };
@@ -67399,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) => {
@@ -67474,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) => {
@@ -67528,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) {
@@ -67789,6 +67808,9 @@ return ${compiler2.callType("value", tagType)}
     get root() {
       return this._root;
     }
+    get cacheId() {
+      return `hosted:${this._root}`;
+    }
     get options() {
       return this._options;
     }
@@ -77313,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) => {
@@ -77340,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();
     }
@@ -77392,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);
@@ -77407,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);
@@ -77468,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;
 
@@ -77511,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;
@@ -80364,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,
@@ -81199,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 = {
@@ -81332,14 +81342,112 @@ return ${compiler2.callType("value", tagType)}
 
   // src/skin/scene/SkinObject.ts
   var import_ts_deepmerge7 = __toESM(require_dist());
+
+  // src/skin/SkinTextures.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var SkinTextures = class {
+    static async get(src, legacy) {
+      const image = await ImageLoader.getData(src);
+      const scale = image.width / 64;
+      if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width && image.height !== image.width / 2) {
+        throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; expected 64x64 or 64x32, or an integer-scaled equivalent`);
+      }
+      const isLegacy = legacy ?? image.height === image.width / 2;
+      if (!isLegacy && image.height !== image.width) {
+        throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; non-legacy skins must be square`);
+      }
+      const slim = !isLegacy && this.isSlim(image, scale);
+      const key = `skin:${serializeImageKey({ src })}:${isLegacy}`;
+      const material = Caching.materialCache.get(key, () => {
+        const pixels = isLegacy ? this.normalizeLegacy(image, scale) : new Uint8Array(image.data);
+        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++) {
+          for (let column = x4 * scale; column < (x4 + 1) * scale; column++) {
+            if (image.data[(row * image.width + column) * 4 + 3] !== 0) return false;
+          }
+        }
+      }
+      return true;
+    }
+    static normalizeLegacy(image, scale) {
+      const pixels = new Uint8Array(image.width * image.width * 4);
+      pixels.set(image.data.subarray(0, image.width * image.width / 2 * 4));
+      for (const [sx, sy, dx, dy, width, height] of [
+        [4, 16, 20, 48, 4, 4],
+        [8, 16, 24, 48, 4, 4],
+        [0, 20, 24, 52, 4, 12],
+        [4, 20, 20, 52, 4, 12],
+        [8, 20, 16, 52, 4, 12],
+        [12, 20, 28, 52, 4, 12],
+        [44, 16, 36, 48, 4, 4],
+        [48, 16, 40, 48, 4, 4],
+        [40, 20, 40, 52, 4, 12],
+        [44, 20, 36, 52, 4, 12],
+        [48, 20, 32, 52, 4, 12],
+        [52, 20, 44, 52, 4, 12]
+      ]) {
+        for (let y5 = 0; y5 < height * scale; y5++) {
+          for (let x4 = 0; x4 < width * scale; x4++) {
+            const source = ((sy * scale + y5) * image.width + sx * scale + x4) * 4;
+            const target = ((dy * scale + y5) * image.width + (dx + width) * scale - 1 - x4) * 4;
+            pixels.set(image.data.subarray(source, source + 4), target);
+          }
+        }
+      }
+      let clearHat = true;
+      for (let y5 = 0; y5 < 32 * scale; y5++) {
+        for (let x4 = 32 * scale; x4 < image.width; x4++) {
+          if (pixels[(y5 * image.width + x4) * 4 + 3] < 128) clearHat = false;
+        }
+      }
+      for (let y5 = 0; y5 < image.width; y5++) {
+        for (let x4 = 0; x4 < image.width; x4++) {
+          const alpha = (y5 * image.width + x4) * 4 + 3;
+          if (x4 < 32 * scale && y5 < 16 * scale || y5 >= 16 * scale && y5 < 32 * scale || x4 >= 16 * scale && x4 < 48 * scale && y5 >= 48 * scale) {
+            pixels[alpha] = 255;
+          } else if (clearHat && x4 >= 32 * scale && y5 < 32 * scale) {
+            pixels[alpha] = 0;
+          }
+        }
+      }
+      return pixels;
+    }
+  };
+
+  // src/skin/scene/SkinObject.ts
   var SkinObject = class extends SceneObject {
     constructor(options) {
       super();
       this.slim = false;
-      this.legacy = false;
-      this.skinTextureWidth = 64;
-      this.skinTextureHeight = 64;
+      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;
     }
     async init() {
       this.createMeshes();
@@ -81348,15 +81456,13 @@ return ${compiler2.callType("value", tagType)}
     }
     createMeshes() {
       console.log("#createMeshes");
-      const mat = Materials.MISSING_TEXTURE;
+      const mat = this.skinMaterial ?? Materials.MISSING_TEXTURE;
       {
         const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
         const headGeo = this.getBoxGeometry("head" /* HEAD */);
         const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
-        if (!this.legacy) {
-          const hatGeo = this.getBoxGeometry("hat" /* HAT */);
-          const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
-        }
+        const hatGeo = this.getBoxGeometry("hat" /* HAT */);
+        const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
       }
       {
         const bodyGroup = this.createAndAddGroup("body", 0, 18, 0);
@@ -81399,21 +81505,58 @@ return ${compiler2.callType("value", tagType)}
       }
       console.log("#createMeshes done");
     }
-    setSkinTexture(src) {
+    async setSkinTexture(src) {
       if (typeof src === "undefined") return;
-      const mat = Materials.getImage({
-        texture: { src },
-        transparent: true
-      });
-      for (let part of SKIN_PARTS) {
-        let mesh = this.getMeshByName(part);
+      this.skinTextureSrc = src;
+      const load = ++this.skinLoad;
+      const texture = await SkinTextures.get(src, this.options.legacy);
+      if (load !== this.skinLoad) return;
+      this.skinMaterial = texture.material;
+      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 = mat;
+          mesh.material = texture.material;
         }
       }
+      this.notifyDirty();
+    }
+    /** 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();
     }
-    //TODO: cape
+    /** Select the arm model, or pass undefined to use texture detection. */
     setSlim(slim) {
+      this.options.slim = slim;
+      this.updateSlim(slim ?? this.detectedSlim);
+    }
+    updateSlim(slim) {
       if (slim === this.slim) return;
       this.slim = slim;
       for (const part of ["leftArm" /* LEFT_ARM */, "leftSleeve" /* LEFT_SLEEVE */, "rightArm" /* RIGHT_ARM */, "rightSleeve" /* RIGHT_SLEEVE */]) {
@@ -81427,17 +81570,23 @@ return ${compiler2.callType("value", tagType)}
       if (rightArm) rightArm.position.x -= offset;
       this.notifyDirty();
     }
-    setLegacy(legacy) {
-      if (legacy !== this.legacy) {
-      }
-      this.legacy = legacy;
+    /** Select the texture layout, or pass undefined to detect it from image dimensions. */
+    async setLegacy(legacy) {
+      if (legacy === this.options.legacy) return;
+      this.options.legacy = legacy;
+      if (this.skinTextureSrc) await this.setSkinTexture(this.skinTextureSrc);
+    }
+    dispose() {
+      this.skinLoad++;
+      this.capeLoad++;
+      super.dispose();
     }
     //TODO: layer toggles
     getBoxGeometry(part) {
       console.log("slim", this.slim);
       const coordinates = this.slim ? slimSkinTextureCoordinates : classicSkinTextureCoordinates;
       const geometries = this.slim ? slimSkinGeometries : classicSkinGeometries;
-      return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [this.skinTextureWidth, this.skinTextureHeight]);
+      return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [64, 64]);
     }
   };
 
@@ -81547,10 +81696,10 @@ return ${compiler2.callType("value", tagType)}
       this.dirty = true;
       const obj = new SkinObject(options);
       obj.scene = this;
-      await obj.init();
       if (skin) {
-        obj.setSkinTexture(skin);
+        await obj.setSkinTexture(skin);
       }
+      await obj.init();
       parent.add(obj);
       return obj;
     }