minerender 2.1.0-alpha.32 → 2.1.0-alpha.34

package/dist/node/index.mjs

@@ -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;
@@ -2818,7 +2832,7 @@ var Entities = class {
 };
 
 // src/renderer/SceneObject.ts
-import { Euler as Euler3, InstancedMesh, MathUtils, Matrix4 as Matrix43, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector35 } from "three";
+import { Color as Color2, Euler as Euler3, InstancedBufferAttribute, InstancedMesh, MathUtils, Matrix4 as Matrix43, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector35 } from "three";
 
 // src/instance/InstanceReference.ts
 var InstanceReference = class {
@@ -2830,32 +2844,42 @@ var InstanceReference = class {
   nextInstance() {
     return this.instanceable.nextInstance();
   }
+  get activeInstanceable() {
+    if (!this.instanceable.isInstanceActive(this.index, this)) throw new MineRenderError("Instance has been removed");
+    return this.instanceable;
+  }
+  removeFromScene() {
+    if (this.instanceable.isInstanceActive(this.index, this)) this.instanceable.removeInstanceAt(this.index);
+  }
+  dispose() {
+    this.removeFromScene();
+  }
   getMatrix(matrix) {
-    return this.instanceable.getMatrixAt(this.index, matrix);
+    return this.activeInstanceable.getMatrixAt(this.index, matrix);
   }
   setMatrix(matrix) {
-    this.instanceable.setMatrixAt(this.index, matrix);
+    this.activeInstanceable.setMatrixAt(this.index, matrix);
   }
   setPositionRotationScale(position, rotation, scale) {
-    this.instanceable.setPositionRotationScaleAt(this.index, position, rotation, scale);
+    this.activeInstanceable.setPositionRotationScaleAt(this.index, position, rotation, scale);
   }
   setPosition(position) {
-    this.instanceable.setPositionAt(this.index, position);
+    this.activeInstanceable.setPositionAt(this.index, position);
   }
   getPosition() {
-    return this.instanceable.getPositionAt(this.index);
+    return this.activeInstanceable.getPositionAt(this.index);
   }
   setRotation(rotation) {
-    this.instanceable.setRotationAt(this.index, rotation);
+    this.activeInstanceable.setRotationAt(this.index, rotation);
   }
   getRotation() {
-    return this.instanceable.getRotationAt(this.index);
+    return this.activeInstanceable.getRotationAt(this.index);
   }
   setScale(scale) {
-    this.instanceable.setScaleAt(this.index, scale);
+    this.activeInstanceable.setScaleAt(this.index, scale);
   }
   getScale() {
-    return this.instanceable.getScaleAt(this.index);
+    return this.activeInstanceable.getScaleAt(this.index);
   }
   //TODO: support for custom methods e.g. setting block variants
 };
@@ -2873,6 +2897,8 @@ var SceneObject = class _SceneObject extends Object3D2 {
     this.materialCallbacks = {};
     this._isInstanced = false;
     this._instanceCounter = 0;
+    this.instanceReferences = /* @__PURE__ */ new Map();
+    this.freeInstanceIndices = [];
     this.options = (0, import_ts_deepmerge3.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
     console.log("SceneObject options", this.options);
   }
@@ -2976,6 +3002,8 @@ var SceneObject = class _SceneObject extends Object3D2 {
   createInstancedMesh(name, geometry, material, count) {
     const mesh = new InstancedMesh(geometry, material, count);
     mesh.count = 0;
+    this.instanceMesh = mesh;
+    this._isInstanced = true;
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -3043,40 +3071,70 @@ var SceneObject = class _SceneObject extends Object3D2 {
     return new InstanceReference(this, i);
   }
   nextInstance() {
-    if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const i = this._instanceCounter++;
-    this.setMatrixAt(i, new Matrix43());
-    const mesh = this.children[0];
-    if (mesh && isInstancedMesh(mesh)) {
-      mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
-    }
-    console.debug(p6, "nextInstance " + i);
-    if (i === this.options.maxInstanceCount) {
-      console.warn(p6, "Max instance count reached for " + this);
-    }
-    if (this.scene) {
-      this.scene.stats.instanceCount++;
+    const mesh = this.instanceMesh;
+    if (!mesh) throw new MineRenderError("Object is not instanced");
+    const index = this.freeInstanceIndices.pop() ?? mesh.count;
+    if (index >= mesh.instanceMatrix.count) this.growInstances(index + 1);
+    const reference = this.constructInstanceReference(index);
+    this.instanceReferences.set(index, reference);
+    this._instanceCounter = this.instanceReferences.size;
+    mesh.count = Math.max(mesh.count, index + 1);
+    if (mesh.instanceColor) {
+      mesh.setColorAt(index, new Color2(16777215));
+      mesh.instanceColor.needsUpdate = true;
+    }
+    if (this._scene) this._scene.stats.instanceCount++;
+    this.setMatrixAt(index, new Matrix43());
+    return reference;
+  }
+  isInstanceActive(index, reference) {
+    return this.instanceReferences.get(index) === reference;
+  }
+  removeInstanceAt(index) {
+    if (!this.instanceReferences.has(index)) return;
+    const mesh = this.instanceMesh;
+    this.setMatrixAt(index, new Matrix43().makeScale(0, 0, 0));
+    this.instanceReferences.delete(index);
+    this.freeInstanceIndices.push(index);
+    this._instanceCounter = this.instanceReferences.size;
+    while (mesh.count > 0 && !this.instanceReferences.has(mesh.count - 1)) mesh.count--;
+    if (this._scene) this._scene.stats.instanceCount--;
+  }
+  growInstances(required) {
+    const mesh = this.instanceMesh;
+    const capacity = Math.max(required, mesh.instanceMatrix.count * 2);
+    const grow = (attribute, fill) => {
+      const array = new Float32Array(capacity * attribute.itemSize).fill(fill);
+      array.set(attribute.array);
+      return new InstancedBufferAttribute(array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute).setUsage(attribute.usage);
+    };
+    const matrix = grow(mesh.instanceMatrix, 0);
+    const color = mesh.instanceColor ? grow(mesh.instanceColor, 1) : null;
+    mesh.dispose();
+    mesh.instanceMatrix = matrix;
+    mesh.instanceColor = color;
+  }
+  *activeInstanceIndices() {
+    if (this.instanceMesh) {
+      yield* this.instanceReferences.keys();
+    } else {
+      for (let i = 0; i < this.instanceCounter; i++) yield i;
     }
-    this.notifyDirty();
-    return this.constructInstanceReference(i);
   }
   //</editor-fold>
   //<editor-fold desc="TRANSFORMATION">
   getMatrixAt(index, matrix = new Matrix43()) {
-    if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const child = this.children[0];
-    if (child && isInstancedMesh(child)) {
-      child.getMatrixAt(index, matrix);
-    }
+    if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
+    this.instanceMesh.getMatrixAt(index, matrix);
     return matrix;
   }
   setMatrixAt(index, matrix) {
-    if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const child = this.children[0];
-    if (child && isInstancedMesh(child)) {
-      child.setMatrixAt(index, matrix);
-      child.instanceMatrix.needsUpdate = true;
-    }
+    if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
+    const mesh = this.instanceMesh;
+    mesh.setMatrixAt(index, matrix);
+    mesh.instanceMatrix.needsUpdate = true;
+    mesh.boundingBox = null;
+    mesh.boundingSphere = null;
     this.notifyDirty();
   }
   setPositionRotationScaleAt(index, position, rotation, scale) {
@@ -3127,7 +3185,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   setPositionRotationScale(position, rotation, scale) {
     if (this.isInstanced) {
-      for (let i = 0; i < this.instanceCounter; i++) {
+      for (const i of this.activeInstanceIndices()) {
         this.setPositionRotationScaleAt(i, position, rotation, scale);
       }
     } else {
@@ -3145,7 +3203,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   setPosition(position) {
     if (this.isInstanced) {
-      for (let i = 0; i < this.instanceCounter; i++) {
+      for (const i of this.activeInstanceIndices()) {
         this.setPositionRotationScaleAt(i, position);
       }
     } else {
@@ -3155,14 +3213,14 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   getPosition() {
     if (this.isInstanced) {
-      return this.getPositionAt(0);
+      return this.getPositionAt(this.instanceReferences.keys().next().value ?? 0);
     } else {
       return this.position;
     }
   }
   setRotation(rotation) {
     if (this.isInstanced) {
-      for (let i = 0; i < this.instanceCounter; i++) {
+      for (const i of this.activeInstanceIndices()) {
         this.setPositionRotationScaleAt(i, void 0, rotation);
       }
     } else {
@@ -3172,14 +3230,14 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   getRotation() {
     if (this.isInstanced) {
-      return this.getRotationAt(0);
+      return this.getRotationAt(this.instanceReferences.keys().next().value ?? 0);
     } else {
       return this.rotation;
     }
   }
   setScale(scale) {
     if (this.isInstanced) {
-      for (let i = 0; i < this.instanceCounter; i++) {
+      for (const i of this.activeInstanceIndices()) {
         this.setPositionRotationScaleAt(i, void 0, void 0, scale);
       }
     } else {
@@ -3189,7 +3247,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   getScale() {
     if (this.isInstanced) {
-      return this.getScaleAt(0);
+      return this.getScaleAt(this.instanceReferences.keys().next().value ?? 0);
     } else {
       return this.scale;
     }
@@ -3213,6 +3271,17 @@ var SceneObject = class _SceneObject extends Object3D2 {
     this.notifyDirty();
   }
   disposeAndRemoveAllChildren() {
+    if (this.instanceMesh) {
+      if (this._scene) this._scene.stats.instanceCount -= this.instanceReferences.size;
+      this.instanceReferences.clear();
+      this.freeInstanceIndices.length = 0;
+      this._instanceCounter = 0;
+      this.instanceMesh.count = 0;
+      this.instanceMesh.dispose();
+      this.instanceMesh.removeFromParent();
+      this.instanceMesh = void 0;
+      this._isInstanced = false;
+    }
     while (this.children.length > 0) {
       let c = this.children[0];
       if (isDisposable(c)) {
@@ -3253,9 +3322,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 +3346,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 +3381,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();
   }
 };
@@ -4418,10 +4504,6 @@ var ModelObject = class _ModelObject extends SceneObject {
     this.createMeshes();
     this.applyTextures();
   }
-  dispose() {
-    super.dispose();
-    this.atlas?.dispose();
-  }
   get textureAtlas() {
     return this.atlas;
   }
@@ -4535,7 +4617,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-import { Euler as Euler5, Matrix4 as Matrix45, Vector3 as Vector37 } from "three";
+import { Euler as Euler5, Matrix4 as Matrix45 } from "three";
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4590,18 +4672,21 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
   }
   dispose() {
+    this.clearModels();
     super.dispose();
   }
   removeFromScene() {
-    for (let model of this._models) {
-      if (isModelObject(model)) {
-        model.removeFromScene();
-      } else if (isInstanceReference(model)) {
-        model.setScale(new Vector37(0, 0, 0));
-      }
-    }
+    this.clearModels();
     super.removeFromScene();
   }
+  clearModels() {
+    for (const model of this._models.splice(0)) {
+      model.removeFromScene();
+      if (!isInstanceReference(model)) model.dispose();
+    }
+    this._isInstanced = false;
+    this._instanceCounter = 0;
+  }
   get state() {
     return this._state;
   }
@@ -4650,22 +4735,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     return out;
   }
   async recreateModels() {
-    const instanceInfo = [];
-    if (this.isInstanced) {
-      for (let i = 0; i < this.instanceCounter; i++) {
-        instanceInfo[i] = this.getMatrixAt(i);
-      }
-    }
-    for (let model of this._models) {
-      if (isInstanceReference(model)) {
-        model.setScale(new Vector37(0, 0, 0));
-      } else {
-        model.dispose();
-      }
-    }
-    while (this._models.length > 0) {
-      this._models.shift();
-    }
+    this.clearModels();
     const variantsToCreate = await this.mapStateToVariant(this.state);
     this._variants = variantsToCreate;
     for (let blockStateVariant of variantsToCreate) {
@@ -4716,6 +4786,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       this._instanceCounter = 1;
     }
     obj.setRotation(rotation);
+    obj.setPosition(this.position);
     return obj;
   }
   async resetState() {