minerender 2.1.0-alpha.33 → 2.1.0-alpha.35

package/dist/browser/index.mjs

@@ -2788,7 +2788,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 {
@@ -2800,32 +2800,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
 };
@@ -2843,6 +2853,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);
   }
@@ -2938,6 +2950,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}`;
     }
@@ -3005,40 +3019,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) {
@@ -3089,7 +3133,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 {
@@ -3107,7 +3151,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 {
@@ -3117,14 +3161,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 {
@@ -3134,14 +3178,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 {
@@ -3151,7 +3195,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;
     }
@@ -3175,6 +3219,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)) {
@@ -4400,10 +4455,6 @@ var _ModelObject = class _ModelObject extends SceneObject {
     this.createMeshes();
     this.applyTextures();
   }
-  dispose() {
-    super.dispose();
-    this.atlas?.dispose();
-  }
   get textureAtlas() {
     return this.atlas;
   }
@@ -4519,7 +4570,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]) => {
@@ -4569,18 +4620,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;
   }
@@ -4629,22 +4683,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) {
@@ -4695,6 +4734,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       this._instanceCounter = 1;
     }
     obj.setRotation(rotation);
+    obj.setPosition(this.position);
     return obj;
   }
   async resetState() {
@@ -7153,15 +7193,12 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector311 } from "three";
+import { Vector3 as Vector311 } from "three";
 
 // src/world/MineRenderWorld.ts
 import { Vector3 as Vector310 } from "three";
 var MineRenderWorld = class {
   constructor(scene) {
-    this._size = 4;
-    //TODO: expandable
-    this._blockSize = this._size * 16;
     this._chunks = /* @__PURE__ */ new Map();
     this.scene = scene;
   }
@@ -7172,12 +7209,8 @@ var MineRenderWorld = class {
     if (isTripleArray(posOrX)) {
       return this.getBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]));
     }
-    const chunk = this.getChunkAt(posOrX);
-    if (typeof chunk === "undefined") {
-      return void 0;
-    }
     this.validatePosBounds(posOrX);
-    return chunk.getBlockAt(posOrX);
+    return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
@@ -7187,8 +7220,9 @@ var MineRenderWorld = class {
       return this.setBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
-    const chunk = this.getOrCreateChunkAt(posOrX);
-    return chunk.setBlockAt(posOrX, yOrBlock);
+    const value = yOrBlock;
+    const chunk = Chunk.isAir(value) ? this.getChunkAt(posOrX) : this.getOrCreateChunkAt(posOrX);
+    return chunk?.setBlockAt(posOrX, value);
   }
   async placeMultiBlock(multiblock, useBatches = true, executor = new BatchedExecutor()) {
     const keys = new Set(multiblock.blocks.map((block) => AssetKey.parse("blockstates", block.type)));
@@ -7209,10 +7243,8 @@ var MineRenderWorld = class {
     }
   }
   async clear() {
-    console.log("CHUNKS", this._chunks);
-    for (let chunk of this._chunks.values()) {
-      console.log("dispose chunk", chunk);
-      await chunk?.dispose();
+    for (const chunk of this._chunks.values()) {
+      await chunk.dispose();
     }
     this._chunks.clear();
   }
@@ -7226,8 +7258,7 @@ var MineRenderWorld = class {
     return chunk;
   }
   getChunkAt(pos) {
-    const index = this.worldPosToChunkIndex(pos);
-    return this._chunks[index];
+    return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
     return new Vector310(
@@ -7243,12 +7274,6 @@ var MineRenderWorld = class {
       pos.z / 16
     );
   }
-  worldPosToChunkIndex(pos) {
-    const chunkX = Math.floor(pos.x / 16);
-    const chunkY = Math.floor(pos.y / 16);
-    const chunkZ = Math.floor(pos.z / 16);
-    return chunkZ * this._size * this._size + chunkY * this._size + chunkX;
-  }
   worldPosToChunkKey(pos) {
     const chunkX = Math.floor(pos.x / 16);
     const chunkY = Math.floor(pos.y / 16);
@@ -7256,12 +7281,9 @@ var MineRenderWorld = class {
     return `${chunkX}_${chunkY}_${chunkZ}`;
   }
   validatePosBounds(pos) {
-    if (pos.x < 0) throw new Error("x<0");
-    if (pos.y < 0) throw new Error("y<0");
-    if (pos.z < 0) throw new Error("z<0");
-    if (pos.x > this._blockSize) throw new Error("x>" + this._blockSize);
-    if (pos.y > this._blockSize) throw new Error("y>" + this._blockSize);
-    if (pos.z > this._blockSize) throw new Error("z>" + this._blockSize);
+    if (![pos.x, pos.y, pos.z].every(Number.isInteger)) {
+      throw new RangeError("Block coordinates must be integers");
+    }
   }
 };
 
@@ -7274,16 +7296,6 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new Object3D6();
-    this._anchor = anchor;
-    scene.add(anchor);
-    anchor.position.set(this.x * 256 + 128 - 8, this.y * 256 + 128 - 8, this.z * 256 + 128 - 8);
-    addBox3WireframeToObject(
-      new Box32(new Vector311(0, 0, 0), new Vector311(256, 256, 256)),
-      anchor,
-      16776960,
-      4
-    );
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
@@ -7309,7 +7321,7 @@ var Chunk = class _Chunk {
     return this.setBlockInChunkAt(pos, block, worldPos);
   }
   /**
-   * Set block at a _chunk_ position (0-16)
+   * Set a block at integer chunk-local coordinates from 0 to 15.
    */
   async setBlockInChunkAt(pos, block, worldPos) {
     if (typeof worldPos === "undefined") {
@@ -7322,15 +7334,13 @@ var Chunk = class _Chunk {
       current.object.removeFromScene();
       delete this._blocks[index];
     }
-    if (typeof block === "undefined" || typeof block.type === "undefined" || block.type === "air") return void 0;
+    if (!block || _Chunk.isAir(block)) return void 0;
     const blockState = await BlockStates.get(AssetKey.parse("blockstates", block.type));
     if (blockState) {
       const blockObject = await this.scene.addBlock(blockState, {
         mergeMeshes: true,
         instanceMeshes: true,
-        wireframe: true,
         maxInstanceCount: 2e3
-        //TODO: setting this to high kills FPS; increase on demand somehow?
       });
       if (block.properties) {
         await blockObject.setState(block.properties);
@@ -7346,23 +7356,21 @@ var Chunk = class _Chunk {
     return void 0;
   }
   async clear() {
-    let promises = [];
-    let pos = new Vector311();
-    for (let x = 0; x < 16; x++) {
-      for (let z = 0; z < 16; z++) {
-        for (let y = 0; y < 16; y++) {
-          promises.push(this.setBlockInChunkAt(pos.set(x, y, z), void 0));
-        }
-      }
-    }
-    return Promise.all(promises).then((ignored) => {
-    });
+    this._blocks.forEach((block) => block.object.removeFromScene());
+    this._blocks.length = 0;
   }
   async dispose() {
     await this.clear();
-    this.scene.remove(this._anchor);
+  }
+  static isAir(block) {
+    if (typeof block === "undefined" || typeof block.type === "undefined") return true;
+    const key = AssetKey.parse("blockstates", block.type);
+    return key.namespace === "minecraft" && !key.type && ["air", "cave_air", "void_air"].includes(key.path);
   }
   static chunkPosToBlockIndex(pos) {
+    if ([pos.x, pos.y, pos.z].some((value) => !Number.isInteger(value) || value < 0 || value >= 16)) {
+      throw new RangeError("Block coordinates must be integers from 0 to 15 within a chunk");
+    }
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {