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

package/dist/node/index.mjs

@@ -288,7 +288,7 @@ function isDisposable(obj) {
 import { BoxGeometry, Float32BufferAttribute } from "three";
 
 // src/util/util.ts
-import * as CryptoJS from "crypto-js";
+import CryptoJS from "crypto-js";
 var changeEvent = { type: "change" };
 function md5(str) {
   return CryptoJS.MD5(str).toString(CryptoJS.enc.Hex);
@@ -2765,26 +2765,40 @@ var Entities = class {
     };
     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((name) => {
+      const layer = model.layers[name];
+      if (!layer) {
+        throw new MineRenderError(`Entity ${model.id} has no layer "${name}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+      }
+      return { name, layer };
+    });
+    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer }, index) => {
+      const override = options?.textures?.[name] ?? (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 [name, { 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;
@@ -3253,9 +3267,21 @@ var EntityObject = class _EntityObject extends SceneObject {
   dispose() {
     super.dispose();
   }
-  get textureKey() {
-    if (this.entity.texture) return this.entity.texture;
-    const key = this.entity.key;
+  getLayerGroup(name) {
+    return super.getGroupByName(`layer:${name}`);
+  }
+  getGroupByName(name, layerName) {
+    return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
+  }
+  getMeshByName(name, layerName) {
+    return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
+  }
+  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,
@@ -3265,18 +3291,22 @@ var EntityObject = class _EntityObject extends SceneObject {
       ".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 Object3D3();
     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(([name, layer], index) => {
+      const group = this.createGroup(`layer:${name}`);
+      modelRoot.add(group);
+      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index);
+    });
     this.meshesCreated = true;
   }
-  createPart(name, part, parent, textureSize, material) {
+  createPart(name, part, parent, textureSize, material, renderOrder) {
     const anchor = this.createGroup(name);
     anchor.position.fromArray(part.pose.offset);
     anchor.rotation.set(...part.pose.rotation, "ZYX");
@@ -3296,30 +3326,31 @@ var EntityObject = class _EntityObject extends SceneObject {
       ).clone();
       geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
       const mesh = this.createMesh(name, 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 ([name, 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(name)?.traverse((object) => {
+        if (isMesh(object)) object.material = mat;
+      });
+    }));
     this.notifyDirty();
   }
 };