minerender 2.1.0-alpha.27 → 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 = {
@@ -5581,14 +5582,110 @@ var slimSkinGeometries = {
 
 // src/skin/scene/SkinObject.ts
 var import_ts_deepmerge7 = __toESM(require_dist());
+
+// src/skin/SkinTextures.ts
+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);
+    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 = 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++) {
+        for (let column = x * scale; column < (x + 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 y = 0; y < height * scale; y++) {
+        for (let x = 0; x < width * scale; x++) {
+          const source = ((sy * scale + y) * image.width + sx * scale + x) * 4;
+          const target = ((dy * scale + y) * image.width + (dx + width) * scale - 1 - x) * 4;
+          pixels.set(image.data.subarray(source, source + 4), target);
+        }
+      }
+    }
+    let clearHat = true;
+    for (let y = 0; y < 32 * scale; y++) {
+      for (let x = 32 * scale; x < image.width; x++) {
+        if (pixels[(y * image.width + x) * 4 + 3] < 128) clearHat = false;
+      }
+    }
+    for (let y = 0; y < image.width; y++) {
+      for (let x = 0; x < image.width; x++) {
+        const alpha = (y * image.width + x) * 4 + 3;
+        if (x < 32 * scale && y < 16 * scale || y >= 16 * scale && y < 32 * scale || x >= 16 * scale && x < 48 * scale && y >= 48 * scale) {
+          pixels[alpha] = 255;
+        } else if (clearHat && x >= 32 * scale && y < 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();
@@ -5597,15 +5694,13 @@ var SkinObject = class extends SceneObject {
   }
   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);
@@ -5648,21 +5743,58 @@ var SkinObject = class extends SceneObject {
     }
     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();
   }
-  //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;
+    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 */]) {
@@ -5676,17 +5808,23 @@ var SkinObject = class extends SceneObject {
     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]);
   }
 };
 
@@ -5799,10 +5937,10 @@ var MineRenderScene = class _MineRenderScene extends Scene2 {
     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;
   }
@@ -5815,7 +5953,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector39, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace4, Vector3 as Vector39, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
@@ -6569,7 +6707,7 @@ var Renderer = class _Renderer {
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
     renderer.shadowMap.type = PCFSoftShadowMap;
-    renderer.outputColorSpace = SRGBColorSpace3;
+    renderer.outputColorSpace = SRGBColorSpace4;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -7276,6 +7414,7 @@ export {
   SchematicParser,
   SkinObject,
   SkinPart,
+  SkinTextures,
   Skins,
   StructureParser,
   TextureAtlas,