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

package/dist/bundle.js

@@ -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;
@@ -81203,32 +81217,42 @@ ${key}` : key;
     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
   };
@@ -81246,6 +81270,8 @@ ${key}` : key;
       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);
     }
@@ -81341,6 +81367,8 @@ ${key}` : key;
     createInstancedMesh(name2, geometry, material, count) {
       const mesh = new InstancedMesh(geometry, material, count);
       mesh.count = 0;
+      this.instanceMesh = mesh;
+      this._isInstanced = true;
       if (name2) {
         mesh.name = `mesh:${name2}`;
       }
@@ -81408,40 +81436,70 @@ ${key}` : key;
       return new InstanceReference(this, i4);
     }
     nextInstance() {
-      if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-      const i4 = this._instanceCounter++;
-      this.setMatrixAt(i4, new Matrix4());
-      const mesh = this.children[0];
-      if (mesh && isInstancedMesh(mesh)) {
-        mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
-      }
-      console.debug(p9, "nextInstance " + i4);
-      if (i4 === this.options.maxInstanceCount) {
-        console.warn(p9, "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 Color(16777215));
+        mesh.instanceColor.needsUpdate = true;
+      }
+      if (this._scene) this._scene.stats.instanceCount++;
+      this.setMatrixAt(index, new Matrix4());
+      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 Matrix4().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 color2 = mesh.instanceColor ? grow(mesh.instanceColor, 1) : null;
+      mesh.dispose();
+      mesh.instanceMatrix = matrix;
+      mesh.instanceColor = color2;
+    }
+    *activeInstanceIndices() {
+      if (this.instanceMesh) {
+        yield* this.instanceReferences.keys();
+      } else {
+        for (let i4 = 0; i4 < this.instanceCounter; i4++) yield i4;
       }
-      this.notifyDirty();
-      return this.constructInstanceReference(i4);
     }
     //</editor-fold>
     //<editor-fold desc="TRANSFORMATION">
     getMatrixAt(index, matrix = new Matrix4()) {
-      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) {
@@ -81492,7 +81550,7 @@ ${key}` : key;
     }
     setPositionRotationScale(position, rotation, scale) {
       if (this.isInstanced) {
-        for (let i4 = 0; i4 < this.instanceCounter; i4++) {
+        for (const i4 of this.activeInstanceIndices()) {
           this.setPositionRotationScaleAt(i4, position, rotation, scale);
         }
       } else {
@@ -81510,7 +81568,7 @@ ${key}` : key;
     }
     setPosition(position) {
       if (this.isInstanced) {
-        for (let i4 = 0; i4 < this.instanceCounter; i4++) {
+        for (const i4 of this.activeInstanceIndices()) {
           this.setPositionRotationScaleAt(i4, position);
         }
       } else {
@@ -81520,14 +81578,14 @@ ${key}` : key;
     }
     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 i4 = 0; i4 < this.instanceCounter; i4++) {
+        for (const i4 of this.activeInstanceIndices()) {
           this.setPositionRotationScaleAt(i4, void 0, rotation);
         }
       } else {
@@ -81537,14 +81595,14 @@ ${key}` : key;
     }
     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 i4 = 0; i4 < this.instanceCounter; i4++) {
+        for (const i4 of this.activeInstanceIndices()) {
           this.setPositionRotationScaleAt(i4, void 0, void 0, scale);
         }
       } else {
@@ -81554,7 +81612,7 @@ ${key}` : key;
     }
     getScale() {
       if (this.isInstanced) {
-        return this.getScaleAt(0);
+        return this.getScaleAt(this.instanceReferences.keys().next().value ?? 0);
       } else {
         return this.scale;
       }
@@ -81578,6 +81636,17 @@ ${key}` : key;
       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 c4 = this.children[0];
         if (isDisposable(c4)) {
@@ -81621,9 +81690,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 +81714,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 +81749,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();
     }
   };
@@ -82874,10 +82960,6 @@ ${key}` : key;
       this.createMeshes();
       this.applyTextures();
     }
-    dispose() {
-      super.dispose();
-      this.atlas?.dispose();
-    }
     get textureAtlas() {
       return this.atlas;
     }
@@ -83042,18 +83124,21 @@ ${key}` : key;
       }
     }
     dispose() {
+      this.clearModels();
       super.dispose();
     }
     removeFromScene() {
-      for (let model of this._models) {
-        if (isModelObject(model)) {
-          model.removeFromScene();
-        } else if (isInstanceReference(model)) {
-          model.setScale(new Vector3(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;
     }
@@ -83102,22 +83187,7 @@ ${key}` : key;
       return out;
     }
     async recreateModels() {
-      const instanceInfo = [];
-      if (this.isInstanced) {
-        for (let i4 = 0; i4 < this.instanceCounter; i4++) {
-          instanceInfo[i4] = this.getMatrixAt(i4);
-        }
-      }
-      for (let model of this._models) {
-        if (isInstanceReference(model)) {
-          model.setScale(new Vector3(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) {
@@ -83168,6 +83238,7 @@ ${key}` : key;
         this._instanceCounter = 1;
       }
       obj.setRotation(rotation);
+      obj.setPosition(this.position);
       return obj;
     }
     async resetState() {