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

package/dist/bundle.js

@@ -81217,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
   };
@@ -81260,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);
     }
@@ -81355,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}`;
       }
@@ -81422,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) {
@@ -81506,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 {
@@ -81524,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 {
@@ -81534,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 {
@@ -81551,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 {
@@ -81568,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;
       }
@@ -81592,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)) {
@@ -82905,10 +82960,6 @@ ${key}` : key;
       this.createMeshes();
       this.applyTextures();
     }
-    dispose() {
-      super.dispose();
-      this.atlas?.dispose();
-    }
     get textureAtlas() {
       return this.atlas;
     }
@@ -83073,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;
     }
@@ -83133,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) {
@@ -83199,6 +83238,7 @@ ${key}` : key;
         this._instanceCounter = 1;
       }
       obj.setRotation(rotation);
+      obj.setPosition(this.position);
       return obj;
     }
     async resetState() {
@@ -87513,9 +87553,6 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
   init_process2();
   var MineRenderWorld = class {
     constructor(scene) {
-      this._size = 4;
-      //TODO: expandable
-      this._blockSize = this._size * 16;
       this._chunks = /* @__PURE__ */ new Map();
       this.scene = scene;
     }
@@ -87526,12 +87563,8 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       if (isTripleArray(posOrX)) {
         return this.getBlockAt(new Vector3(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, z4, block) {
       if (typeof posOrX == "number") {
@@ -87541,8 +87574,9 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         return this.setBlockAt(new Vector3(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)));
@@ -87563,10 +87597,8 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       }
     }
     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();
     }
@@ -87580,8 +87612,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       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 Vector3(
@@ -87597,12 +87628,6 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         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);
@@ -87610,12 +87635,9 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       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");
+      }
     }
   };
 
@@ -87628,16 +87650,6 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this.x = x4;
       this.y = y5;
       this.z = z4;
-      let anchor = new Object3D();
-      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 Box3(new Vector3(0, 0, 0), new Vector3(256, 256, 256)),
-        anchor,
-        16776960,
-        4
-      );
     }
     getBlockAt(posOrX, y5, z4) {
       if (typeof posOrX == "number") {
@@ -87663,7 +87675,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       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") {
@@ -87676,15 +87688,13 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         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);
@@ -87700,23 +87710,21 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       return void 0;
     }
     async clear() {
-      let promises = [];
-      let pos = new Vector3();
-      for (let x4 = 0; x4 < 16; x4++) {
-        for (let z4 = 0; z4 < 16; z4++) {
-          for (let y5 = 0; y5 < 16; y5++) {
-            promises.push(this.setBlockInChunkAt(pos.set(x4, y5, z4), 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) {