minerender 2.1.0-alpha.34 → 2.1.0-alpha.36

package/dist/bundle.js

@@ -11384,7 +11384,7 @@ var MineRender = (() => {
       Object.defineProperty(exports13, "__esModule", { value: true });
       exports13.JobQueue = void 0;
       var Base_1 = require_Base();
-      var JobQueue2 = class extends Base_1.RunnerBase {
+      var JobQueue3 = class extends Base_1.RunnerBase {
         /**
          * Create a new queue
          * @param runner function(key):Promise to execute the job
@@ -11418,7 +11418,7 @@ var MineRender = (() => {
           }
         }
       };
-      exports13.JobQueue = JobQueue2;
+      exports13.JobQueue = JobQueue3;
     }
   });
 
@@ -70311,24 +70311,20 @@ return ${compiler2.callType("value", tagType)}
   init_dirname();
   init_buffer2();
   init_process2();
+  var import_jobqu2 = __toESM(require_src());
   var BatchedExecutor = class {
     constructor(interval = 1, batch = 30) {
+      if (!Number.isFinite(interval) || interval < 0) throw new RangeError("Batch interval must be finite and nonnegative");
+      if (!Number.isInteger(batch) || batch < 1) throw new RangeError("Batch size must be a positive integer");
       this.interval = interval;
       this.batch = batch;
-      this.queue = [];
-      this.task = setInterval(() => this.run());
+      this.queue = new import_jobqu2.JobQueue(async (task) => task(), { interval, maxPerRun: batch, maxActive: batch });
     }
     submit(task) {
-      this.queue.push(task);
+      return this.queue.add(() => task());
     }
-    run() {
-      for (let i4 = 0; i4 < this.batch; i4++) {
-        this.runNext();
-      }
-    }
-    runNext() {
-      let next = this.queue.shift();
-      if (next) next();
+    stop() {
+      this.queue.end();
     }
   };
 
@@ -87553,9 +87549,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;
     }
@@ -87566,12 +87559,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") {
@@ -87581,32 +87570,48 @@ 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);
-    }
-    async placeMultiBlock(multiblock, useBatches = true, executor = new BatchedExecutor()) {
-      const keys = new Set(multiblock.blocks.map((block) => AssetKey.parse("blockstates", block.type)));
-      await BlockStates.getAll(keys);
-      const place = async (block) => {
-        if (useBatches && typeof executor !== "undefined") {
-          await new Promise((resolve, reject) => {
-            executor.submit(() => {
-              this.setBlockAt(block.position, block).then(resolve).catch(reject);
-            });
-          });
-        } else {
-          await this.setBlockAt(block.position, block);
+      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) {
+      const keys = /* @__PURE__ */ new Map();
+      for (const block of multiblock.blocks) {
+        if (Chunk.isAir(block)) continue;
+        const key = AssetKey.parse("blockstates", block.type);
+        keys.set(key.serialize(), key);
+      }
+      await BlockStates.getAll(keys.values());
+      if (!useBatches) {
+        for (const block of multiblock.blocks) await this.setBlockAt(block.position, block);
+        return;
+      }
+      const positions = /* @__PURE__ */ new Map();
+      for (const block of multiblock.blocks) {
+        const key = block.position.join(",");
+        const group = positions.get(key);
+        if (group) group.push(block);
+        else positions.set(key, [block]);
+      }
+      const groups = [...positions.values()];
+      const queue2 = executor ?? new BatchedExecutor();
+      try {
+        for (let i4 = 0; i4 < groups.length; i4 += queue2.batch) {
+          const results = await Promise.allSettled(groups.slice(i4, i4 + queue2.batch).map(
+            (blocks) => queue2.submit(async () => {
+              for (const block of blocks) await this.setBlockAt(block.position, block);
+            })
+          ));
+          const failure = results.find((result) => result.status === "rejected");
+          if (failure?.status === "rejected") throw failure.reason;
         }
-      };
-      for (let block of multiblock.blocks) {
-        await place(block);
+      } finally {
+        if (!executor) queue2.stop();
       }
     }
     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();
     }
@@ -87620,8 +87625,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(
@@ -87637,12 +87641,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);
@@ -87650,12 +87648,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");
+      }
     }
   };
 
@@ -87668,16 +87663,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") {
@@ -87703,7 +87688,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") {
@@ -87716,15 +87701,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);
@@ -87740,23 +87723,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) {