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

package/dist/node/index.d.mts

@@ -585,13 +585,11 @@ declare class BatchedExecutor {
     readonly interval: number;
     readonly batch: number;
     private readonly queue;
-    private readonly task;
     constructor(interval?: number, batch?: number);
-    submit(task: Task): void;
-    private run;
-    private runNext;
+    submit<T>(task: Task<T>): Promise<T>;
+    stop(): void;
 }
-type Task = () => any | Promise<any>;
+type Task<T = unknown> = () => T | Promise<T>;
 
 declare function prefix(prefix?: string): string;
 
@@ -1692,7 +1690,6 @@ declare class Chunk {
     readonly y: number;
     readonly z: number;
     private readonly _blocks;
-    private readonly _anchor;
     constructor(scene: MineRenderScene, x: number, y: number, z: number);
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
     getBlockAt(pos: Vector3): Maybe<BlockInfo>;
@@ -1704,11 +1701,12 @@ declare class Chunk {
     setBlockAt(pos: Vector3, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     setBlockAt(pos: TripleArray, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     /**
-     * Set block at a _chunk_ position (0-16)
+     * Set a block at integer chunk-local coordinates from 0 to 15.
      */
     setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3): Promise<Maybe<BlockInfo>>;
     clear(): Promise<void>;
     dispose(): Promise<void>;
+    static isAir(block: Maybe<Block>): boolean;
     static chunkPosToBlockIndex(pos: Vector3): number;
     worldPosToChunkPos(pos: Vector3): Vector3;
     chunkPosToWorldPos(pos: Vector3): Vector3;
@@ -1716,23 +1714,20 @@ declare class Chunk {
 
 declare class MineRenderWorld {
     readonly scene: MineRenderScene;
-    private _size;
-    private _blockSize;
     private readonly _chunks;
     constructor(scene: MineRenderScene);
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
     getBlockAt(pos: Vector3): Maybe<BlockInfo>;
     getBlockAt(pos: TripleArray): Maybe<BlockInfo>;
-    setBlockAt(x: number, y: number, z: number, block: Block): Promise<Maybe<BlockInfo>>;
-    setBlockAt(pos: Vector3, block: Block): Promise<Maybe<BlockInfo>>;
-    setBlockAt(pos: TripleArray, block: Block): Promise<Maybe<BlockInfo>>;
+    setBlockAt(x: number, y: number, z: number, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: Vector3, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: TripleArray, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     placeMultiBlock(multiblock: MultiBlockStructure, useBatches?: boolean, executor?: BatchedExecutor): Promise<void>;
     clear(): Promise<void>;
     private getOrCreateChunkAt;
     getChunkAt(pos: Vector3): Maybe<Chunk>;
     static worldToScenePosition(pos: Vector3): Vector3;
     static sceneToWorldPosition(pos: Vector3): Vector3;
-    worldPosToChunkIndex(pos: Vector3): number;
     worldPosToChunkKey(pos: Vector3): string;
     validatePosBounds(pos: Vector3): void;
 }

package/dist/node/index.d.ts

@@ -585,13 +585,11 @@ declare class BatchedExecutor {
     readonly interval: number;
     readonly batch: number;
     private readonly queue;
-    private readonly task;
     constructor(interval?: number, batch?: number);
-    submit(task: Task): void;
-    private run;
-    private runNext;
+    submit<T>(task: Task<T>): Promise<T>;
+    stop(): void;
 }
-type Task = () => any | Promise<any>;
+type Task<T = unknown> = () => T | Promise<T>;
 
 declare function prefix(prefix?: string): string;
 
@@ -1692,7 +1690,6 @@ declare class Chunk {
     readonly y: number;
     readonly z: number;
     private readonly _blocks;
-    private readonly _anchor;
     constructor(scene: MineRenderScene, x: number, y: number, z: number);
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
     getBlockAt(pos: Vector3): Maybe<BlockInfo>;
@@ -1704,11 +1701,12 @@ declare class Chunk {
     setBlockAt(pos: Vector3, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     setBlockAt(pos: TripleArray, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     /**
-     * Set block at a _chunk_ position (0-16)
+     * Set a block at integer chunk-local coordinates from 0 to 15.
      */
     setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3): Promise<Maybe<BlockInfo>>;
     clear(): Promise<void>;
     dispose(): Promise<void>;
+    static isAir(block: Maybe<Block>): boolean;
     static chunkPosToBlockIndex(pos: Vector3): number;
     worldPosToChunkPos(pos: Vector3): Vector3;
     chunkPosToWorldPos(pos: Vector3): Vector3;
@@ -1716,23 +1714,20 @@ declare class Chunk {
 
 declare class MineRenderWorld {
     readonly scene: MineRenderScene;
-    private _size;
-    private _blockSize;
     private readonly _chunks;
     constructor(scene: MineRenderScene);
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
     getBlockAt(pos: Vector3): Maybe<BlockInfo>;
     getBlockAt(pos: TripleArray): Maybe<BlockInfo>;
-    setBlockAt(x: number, y: number, z: number, block: Block): Promise<Maybe<BlockInfo>>;
-    setBlockAt(pos: Vector3, block: Block): Promise<Maybe<BlockInfo>>;
-    setBlockAt(pos: TripleArray, block: Block): Promise<Maybe<BlockInfo>>;
+    setBlockAt(x: number, y: number, z: number, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: Vector3, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: TripleArray, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
     placeMultiBlock(multiblock: MultiBlockStructure, useBatches?: boolean, executor?: BatchedExecutor): Promise<void>;
     clear(): Promise<void>;
     private getOrCreateChunkAt;
     getChunkAt(pos: Vector3): Maybe<Chunk>;
     static worldToScenePosition(pos: Vector3): Vector3;
     static sceneToWorldPosition(pos: Vector3): Vector3;
-    worldPosToChunkIndex(pos: Vector3): number;
     worldPosToChunkKey(pos: Vector3): string;
     validatePosBounds(pos: Vector3): void;
 }

package/dist/node/index.js

@@ -1661,24 +1661,20 @@ var AssetLoadError = class extends Error {
 };
 
 // src/util/BatchedExecutor.ts
+var import_jobqu2 = require("jobqu");
 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 i = 0; i < this.batch; i++) {
-      this.runNext();
-    }
-  }
-  runNext() {
-    let next = this.queue.shift();
-    if (next) next();
+  stop() {
+    this.queue.end();
   }
 };
 
@@ -7388,9 +7384,6 @@ var import_three25 = require("three");
 var import_three24 = require("three");
 var MineRenderWorld = class {
   constructor(scene) {
-    this._size = 4;
-    //TODO: expandable
-    this._blockSize = this._size * 16;
     this._chunks = /* @__PURE__ */ new Map();
     this.scene = scene;
   }
@@ -7401,12 +7394,8 @@ var MineRenderWorld = class {
     if (isTripleArray(posOrX)) {
       return this.getBlockAt(new import_three24.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, z, block) {
     if (typeof posOrX == "number") {
@@ -7416,32 +7405,48 @@ var MineRenderWorld = class {
       return this.setBlockAt(new import_three24.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 queue = executor ?? new BatchedExecutor();
+    try {
+      for (let i = 0; i < groups.length; i += queue.batch) {
+        const results = await Promise.allSettled(groups.slice(i, i + queue.batch).map(
+          (blocks) => queue.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) queue.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();
   }
@@ -7455,8 +7460,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 import_three24.Vector3(
@@ -7472,12 +7476,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);
@@ -7485,12 +7483,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");
+    }
   }
 };
 
@@ -7503,16 +7498,6 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new import_three25.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 import_three25.Box3(new import_three25.Vector3(0, 0, 0), new import_three25.Vector3(256, 256, 256)),
-      anchor,
-      16776960,
-      4
-    );
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
@@ -7538,7 +7523,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") {
@@ -7551,15 +7536,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);
@@ -7575,23 +7558,21 @@ var Chunk = class _Chunk {
     return void 0;
   }
   async clear() {
-    let promises = [];
-    let pos = new import_three25.Vector3();
-    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) {