minerender 2.1.0-alpha.31 → 2.1.0-alpha.33

package/dist/bundle.js

@@ -5332,7 +5332,7 @@ var MineRender = (() => {
               T5[i4] = Math2.abs(Math2.sin(i4 + 1)) * 4294967296 | 0;
             }
           })();
-          var MD52 = C_algo.MD5 = Hasher.extend({
+          var MD5 = C_algo.MD5 = Hasher.extend({
             _doReset: function() {
               this._hash = new WordArray.init([
                 1732584193,
@@ -5479,8 +5479,8 @@ var MineRender = (() => {
             var n4 = a4 + (c4 ^ (b4 | ~d4)) + x4 + t5;
             return (n4 << s4 | n4 >>> 32 - s4) + b4;
           }
-          C5.MD5 = Hasher._createHelper(MD52);
-          C5.HmacMD5 = Hasher._createHmacHelper(MD52);
+          C5.MD5 = Hasher._createHelper(MD5);
+          C5.HmacMD5 = Hasher._createHmacHelper(MD5);
         })(Math);
         return CryptoJS2.MD5;
       });
@@ -5509,7 +5509,7 @@ var MineRender = (() => {
           var Hasher = C_lib.Hasher;
           var C_algo = C5.algo;
           var W3 = [];
-          var SHA12 = C_algo.SHA1 = Hasher.extend({
+          var SHA1 = C_algo.SHA1 = Hasher.extend({
             _doReset: function() {
               this._hash = new WordArray.init([
                 1732584193,
@@ -5573,8 +5573,8 @@ var MineRender = (() => {
               return clone;
             }
           });
-          C5.SHA1 = Hasher._createHelper(SHA12);
-          C5.HmacSHA1 = Hasher._createHmacHelper(SHA12);
+          C5.SHA1 = Hasher._createHelper(SHA1);
+          C5.HmacSHA1 = Hasher._createHmacHelper(SHA1);
         })();
         return CryptoJS2.SHA1;
       });
@@ -5631,7 +5631,7 @@ var MineRender = (() => {
             }
           })();
           var W3 = [];
-          var SHA2562 = C_algo.SHA256 = Hasher.extend({
+          var SHA256 = C_algo.SHA256 = Hasher.extend({
             _doReset: function() {
               this._hash = new WordArray.init(H3.slice(0));
             },
@@ -5697,8 +5697,8 @@ var MineRender = (() => {
               return clone;
             }
           });
-          C5.SHA256 = Hasher._createHelper(SHA2562);
-          C5.HmacSHA256 = Hasher._createHmacHelper(SHA2562);
+          C5.SHA256 = Hasher._createHelper(SHA256);
+          C5.HmacSHA256 = Hasher._createHmacHelper(SHA256);
         })(Math);
         return CryptoJS2.SHA256;
       });
@@ -5725,8 +5725,8 @@ var MineRender = (() => {
           var C_lib = C5.lib;
           var WordArray = C_lib.WordArray;
           var C_algo = C5.algo;
-          var SHA2562 = C_algo.SHA256;
-          var SHA224 = C_algo.SHA224 = SHA2562.extend({
+          var SHA256 = C_algo.SHA256;
+          var SHA224 = C_algo.SHA224 = SHA256.extend({
             _doReset: function() {
               this._hash = new WordArray.init([
                 3238371032,
@@ -5740,13 +5740,13 @@ var MineRender = (() => {
               ]);
             },
             _doFinalize: function() {
-              var hash2 = SHA2562._doFinalize.call(this);
+              var hash2 = SHA256._doFinalize.call(this);
               hash2.sigBytes -= 4;
               return hash2;
             }
           });
-          C5.SHA224 = SHA2562._createHelper(SHA224);
-          C5.HmacSHA224 = SHA2562._createHmacHelper(SHA224);
+          C5.SHA224 = SHA256._createHelper(SHA224);
+          C5.HmacSHA224 = SHA256._createHmacHelper(SHA224);
         })();
         return CryptoJS2.SHA224;
       });
@@ -5867,7 +5867,7 @@ var MineRender = (() => {
               W3[i4] = X64Word_create();
             }
           })();
-          var SHA5122 = C_algo.SHA512 = Hasher.extend({
+          var SHA512 = C_algo.SHA512 = Hasher.extend({
             _doReset: function() {
               this._hash = new X64WordArray.init([
                 new X64Word.init(1779033703, 4089235720),
@@ -6030,8 +6030,8 @@ var MineRender = (() => {
             },
             blockSize: 1024 / 32
           });
-          C5.SHA512 = Hasher._createHelper(SHA5122);
-          C5.HmacSHA512 = Hasher._createHmacHelper(SHA5122);
+          C5.SHA512 = Hasher._createHelper(SHA512);
+          C5.HmacSHA512 = Hasher._createHmacHelper(SHA512);
         })();
         return CryptoJS2.SHA512;
       });
@@ -6059,8 +6059,8 @@ var MineRender = (() => {
           var X64Word = C_x64.Word;
           var X64WordArray = C_x64.WordArray;
           var C_algo = C5.algo;
-          var SHA5122 = C_algo.SHA512;
-          var SHA384 = C_algo.SHA384 = SHA5122.extend({
+          var SHA512 = C_algo.SHA512;
+          var SHA384 = C_algo.SHA384 = SHA512.extend({
             _doReset: function() {
               this._hash = new X64WordArray.init([
                 new X64Word.init(3418070365, 3238371032),
@@ -6074,13 +6074,13 @@ var MineRender = (() => {
               ]);
             },
             _doFinalize: function() {
-              var hash2 = SHA5122._doFinalize.call(this);
+              var hash2 = SHA512._doFinalize.call(this);
               hash2.sigBytes -= 16;
               return hash2;
             }
           });
-          C5.SHA384 = SHA5122._createHelper(SHA384);
-          C5.HmacSHA384 = SHA5122._createHmacHelper(SHA384);
+          C5.SHA384 = SHA512._createHelper(SHA384);
+          C5.HmacSHA384 = SHA512._createHmacHelper(SHA384);
         })();
         return CryptoJS2.SHA384;
       });
@@ -6897,7 +6897,7 @@ var MineRender = (() => {
           var Base = C_lib.Base;
           var WordArray = C_lib.WordArray;
           var C_algo = C5.algo;
-          var SHA2562 = C_algo.SHA256;
+          var SHA256 = C_algo.SHA256;
           var HMAC = C_algo.HMAC;
           var PBKDF2 = C_algo.PBKDF2 = Base.extend({
             /**
@@ -6909,7 +6909,7 @@ var MineRender = (() => {
              */
             cfg: Base.extend({
               keySize: 128 / 32,
-              hasher: SHA2562,
+              hasher: SHA256,
               iterations: 25e4
             }),
             /**
@@ -6998,7 +6998,7 @@ var MineRender = (() => {
           var Base = C_lib.Base;
           var WordArray = C_lib.WordArray;
           var C_algo = C5.algo;
-          var MD52 = C_algo.MD5;
+          var MD5 = C_algo.MD5;
           var EvpKDF = C_algo.EvpKDF = Base.extend({
             /**
              * Configuration options.
@@ -7009,7 +7009,7 @@ var MineRender = (() => {
              */
             cfg: Base.extend({
               keySize: 128 / 32,
-              hasher: MD52,
+              hasher: MD5,
               iterations: 1
             }),
             /**
@@ -16316,9 +16316,9 @@ var MineRender = (() => {
     Readable2.prototype.isPaused = function() {
       return this._readableState.flowing === false;
     };
-    Readable2.prototype.setEncoding = function(enc2) {
+    Readable2.prototype.setEncoding = function(enc) {
       if (!StringDecoder) StringDecoder = e$12.StringDecoder;
-      var decoder = new StringDecoder(enc2);
+      var decoder = new StringDecoder(enc);
       this._readableState.decoder = decoder;
       this._readableState.encoding = this._readableState.decoder.encoding;
       var p15 = this._readableState.buffer.head;
@@ -39612,11 +39612,11 @@ var MineRender = (() => {
             return false;
         }
       };
-      function _normalizeEncoding(enc2) {
-        if (!enc2) return "utf8";
+      function _normalizeEncoding(enc) {
+        if (!enc) return "utf8";
         var retried;
         while (true) {
-          switch (enc2) {
+          switch (enc) {
             case "utf8":
             case "utf-8":
               return "utf8";
@@ -39631,18 +39631,18 @@ var MineRender = (() => {
             case "base64":
             case "ascii":
             case "hex":
-              return enc2;
+              return enc;
             default:
               if (retried) return;
-              enc2 = ("" + enc2).toLowerCase();
+              enc = ("" + enc).toLowerCase();
               retried = true;
           }
         }
       }
-      function normalizeEncoding(enc2) {
-        var nenc = _normalizeEncoding(enc2);
-        if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc2))) throw new Error("Unknown encoding: " + enc2);
-        return nenc || enc2;
+      function normalizeEncoding(enc) {
+        var nenc = _normalizeEncoding(enc);
+        if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+        return nenc || enc;
       }
       exports13.StringDecoder = StringDecoder;
       function StringDecoder(encoding) {
@@ -40184,8 +40184,8 @@ var MineRender = (() => {
         const state = this._readableState;
         return state[kPaused] === true || state.flowing === false;
       };
-      Readable2.prototype.setEncoding = function(enc2) {
-        const decoder = new StringDecoder(enc2);
+      Readable2.prototype.setEncoding = function(enc) {
+        const decoder = new StringDecoder(enc);
         this._readableState.decoder = decoder;
         this._readableState.encoding = this._readableState.decoder.encoding;
         const buffer2 = this._readableState.buffer;
@@ -43372,7 +43372,7 @@ var MineRender = (() => {
         createPacketBuffer(packet) {
           return this.proto.createPacketBuffer(this.mainType, packet);
         }
-        _transform(chunk, enc2, cb) {
+        _transform(chunk, enc, cb) {
           let buf;
           try {
             buf = this.createPacketBuffer(chunk);
@@ -43393,7 +43393,7 @@ var MineRender = (() => {
         parsePacketBuffer(buffer2) {
           return this.proto.parsePacketBuffer(this.mainType, buffer2);
         }
-        _transform(chunk, enc2, cb) {
+        _transform(chunk, enc, cb) {
           this.queue = Buffer.concat([this.queue, chunk]);
           while (true) {
             let packet;
@@ -43423,7 +43423,7 @@ var MineRender = (() => {
         parsePacketBuffer(buffer2) {
           return this.proto.parsePacketBuffer(this.mainType, buffer2);
         }
-        _transform(chunk, enc2, cb) {
+        _transform(chunk, enc, cb) {
           let packet;
           try {
             packet = this.parsePacketBuffer(chunk);
@@ -68079,19 +68079,19 @@ return ${compiler2.callType("value", tagType)}
   init_dirname();
   init_buffer2();
   init_process2();
-  var CryptoJS = __toESM(require_crypto_js());
+  var import_crypto_js = __toESM(require_crypto_js());
   var changeEvent = { type: "change" };
   function md5(str) {
-    return CryptoJS.MD5(str).toString(CryptoJS.enc.Hex);
+    return import_crypto_js.default.MD5(str).toString(import_crypto_js.default.enc.Hex);
   }
   function sha1(str) {
-    return CryptoJS.SHA1(str).toString(CryptoJS.enc.Hex);
+    return import_crypto_js.default.SHA1(str).toString(import_crypto_js.default.enc.Hex);
   }
   function sha256(str) {
-    return CryptoJS.SHA256(str).toString(CryptoJS.enc.Hex);
+    return import_crypto_js.default.SHA256(str).toString(import_crypto_js.default.enc.Hex);
   }
   function sha512(str) {
-    return CryptoJS.SHA512(str).toString(CryptoJS.enc.Hex);
+    return import_crypto_js.default.SHA512(str).toString(import_crypto_js.default.enc.Hex);
   }
   function base64encode(str) {
     if (typeof btoa !== "undefined") {
@@ -81078,26 +81078,40 @@ ${key}` : key;
       };
       return collect("");
     }
-    static async getEntity(modelKey, textureKey, options) {
+    static async getModelFile(modelKey) {
       const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
       const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-      const model = await Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+      return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+    }
+    static async getLayerList(modelKey) {
+      return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
+    }
+    static async getEntity(modelKey, textureKey, options) {
+      const model = await this.getModelFile(modelKey);
       if (!model) return void 0;
-      const layerName = options?.layer ?? "main";
-      const layer = model.layers[layerName];
-      if (!layer) {
-        throw new MineRenderError(`Entity ${model.id} has no layer "${layerName}". Available layers: ${Object.keys(model.layers).join(", ")}`);
-      }
-      let texture;
-      if (textureKey) {
-        const path2 = isAssetKey(textureKey) ? textureKey.getFullPath() : textureKey.path;
-        texture = isAssetKey(textureKey) && textureKey.assetType === "textures" && path2.startsWith("entity/") ? textureKey : new AssetKey(textureKey.namespace, path2, "textures", "entity", "assets", ".png", isAssetKey(textureKey) ? textureKey.root : void 0);
-      } else if (layer.textureLocation !== void 0) {
-        texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
-      } else {
-        texture = await this.resolveTexture(modelKey);
-      }
-      return { key: textureKey ?? modelKey, texture, layer, id: model.id };
+      const names = [...new Set(options?.layers ?? [options?.layer ?? "main"])];
+      if (names.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
+      const selected = names.map((name2) => {
+        const layer = model.layers[name2];
+        if (!layer) {
+          throw new MineRenderError(`Entity ${model.id} has no layer "${name2}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+        }
+        return { name: name2, layer };
+      });
+      const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name: name2, layer }, index) => {
+        const override = options?.textures?.[name2] ?? (index === 0 ? textureKey : void 0);
+        let texture;
+        if (override) {
+          const path = isAssetKey(override) ? override.getFullPath() : override.path;
+          texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
+        } else if (layer.textureLocation !== void 0) {
+          texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+        } else {
+          texture = await this.resolveTexture(modelKey);
+        }
+        return [name2, { key: override ?? modelKey, texture, layer }];
+      })));
+      return { ...layers[names[0]], id: model.id, layers };
     }
     static async resolveTexture(modelKey) {
       const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
@@ -81621,9 +81635,21 @@ ${key}` : key;
     dispose() {
       super.dispose();
     }
-    get textureKey() {
-      if (this.entity.texture) return this.entity.texture;
-      const key = this.entity.key;
+    getLayerGroup(name2) {
+      return super.getGroupByName(`layer:${name2}`);
+    }
+    getGroupByName(name2, layerName) {
+      return layerName === void 0 ? super.getGroupByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name2}`);
+    }
+    getMeshByName(name2, layerName) {
+      return layerName === void 0 ? super.getMeshByName(name2) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name2}`);
+    }
+    get entityLayers() {
+      return this.entity.layers ?? { main: this.entity };
+    }
+    getTextureKey(layer) {
+      if (layer.texture) return layer.texture;
+      const key = layer.key;
       return new AssetKey(
         key.namespace,
         isAssetKey(key) ? key.getFullPath() : key.path,
@@ -81633,18 +81659,22 @@ ${key}` : key;
         ".png"
       );
     }
-    async loadTextures() {
-      this.imageData = await ModelTextures.get(this.textureKey);
+    async loadTextures(layer = this.entity) {
+      return ModelTextures.get(this.getTextureKey(layer));
     }
     createMeshes(force = false) {
       if (this.meshesCreated && !force) return;
       const modelRoot = new Object3D();
       if (this.options.flip) modelRoot.scale.set(-1, -1, 1);
       this.add(modelRoot);
-      this.createPart("root", this.entity.layer.root, modelRoot, this.entity.layer.texture, Materials.MISSING_TEXTURE);
+      Object.entries(this.entityLayers).forEach(([name2, layer], index) => {
+        const group = this.createGroup(`layer:${name2}`);
+        modelRoot.add(group);
+        this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index);
+      });
       this.meshesCreated = true;
     }
-    createPart(name2, part, parent, textureSize, material) {
+    createPart(name2, part, parent, textureSize, material, renderOrder) {
       const anchor = this.createGroup(name2);
       anchor.position.fromArray(part.pose.offset);
       anchor.rotation.set(...part.pose.rotation, "ZYX");
@@ -81664,30 +81694,31 @@ ${key}` : key;
         ).clone();
         geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
         const mesh = this.createMesh(name2, geometry, material);
+        mesh.renderOrder = renderOrder;
         anchor.add(mesh);
         if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
       }
       for (const [childName, child] of Object.entries(part.children)) {
-        this.createPart(childName, child, anchor, size, material);
+        this.createPart(childName, child, anchor, size, material, renderOrder);
       }
     }
     async applyTextures() {
-      const assetKeyStr = this.textureKey.serialize();
-      const keyStr = `entity:${assetKeyStr}`;
-      let mat = Caching.materialCache.getIfPresent(keyStr);
-      if (!mat) {
-        const pending = this.loadTextures();
-        const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
-        await pending;
-        if (!this.imageData) return;
-        const canvas = this.imageData.data.canvas;
-        const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
-        mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
-        this.imageData = void 0;
-      }
-      this.iterateAllMeshes((mesh) => {
-        mesh.material = mat;
-      });
+      await Promise.all(Object.entries(this.entityLayers).map(async ([name2, layer]) => {
+        const assetKeyStr = this.getTextureKey(layer).serialize();
+        const keyStr = `entity:${assetKeyStr}`;
+        let mat = Caching.materialCache.getIfPresent(keyStr);
+        if (!mat) {
+          const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+          const imageData = await this.loadTextures(layer);
+          if (!imageData) return;
+          const canvas = imageData.data.canvas;
+          const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
+          mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+        }
+        this.getLayerGroup(name2)?.traverse((object) => {
+          if (isMesh(object)) object.material = mat;
+        });
+      }));
       this.notifyDirty();
     }
   };