minerender 2.1.0-alpha.33 → 2.1.0-alpha.34

package/dist/node/index.mjs

@@ -2832,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 {
@@ -2844,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
 };
@@ -2887,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);
   }
@@ -2990,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}`;
     }
@@ -3057,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) {
@@ -3141,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 {
@@ -3159,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 {
@@ -3169,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 {
@@ -3186,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 {
@@ -3203,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;
     }
@@ -3227,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)) {
@@ -4449,10 +4504,6 @@ var ModelObject = class _ModelObject extends SceneObject {
     this.createMeshes();
     this.applyTextures();
   }
-  dispose() {
-    super.dispose();
-    this.atlas?.dispose();
-  }
   get textureAtlas() {
     return this.atlas;
   }
@@ -4566,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]) => {
@@ -4621,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;
   }
@@ -4681,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) {
@@ -4747,6 +4786,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       this._instanceCounter = 1;
     }
     obj.setRotation(rotation);
+    obj.setPosition(this.position);
     return obj;
   }
   async resetState() {