minerender 2.1.0-alpha.141 → 2.1.0-alpha.143

package/dist/browser/index.js

@@ -264,8 +264,6 @@ async function sleep(timeout) {
   });
 }
 function yieldToEventLoop() {
-  const scheduler = globalThis.scheduler;
-  if (scheduler?.yield) return scheduler.yield();
   return new Promise((resolve) => {
     if (typeof MessageChannel !== "undefined") {
       const channel = new MessageChannel();
@@ -18669,6 +18667,7 @@ function skipsBlockFace(data, rule, block, neighbor, face) {
 // src/world/MineRenderWorld.ts
 init_log();
 var log19 = logger("MineRenderWorld");
+var YIELD_INTERVAL_MS = 8;
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
@@ -18782,7 +18781,7 @@ var MineRenderWorld = class {
             failures.set(chunk, error);
             if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
           }
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -18937,7 +18936,7 @@ var MineRenderWorld = class {
         )));
         for (const pos of positions) changes.set(`${pos.x},${pos.y},${pos.z}`, pos);
       }
-      if (performance.now() - sliceStart > 8) {
+      if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
         await yieldToEventLoop();
         sliceStart = performance.now();
       }
@@ -18945,6 +18944,62 @@ var MineRenderWorld = class {
   }
   /** Replaces a chunk column's blocks, biomes, and saved light and, with `renderEntities`, its supported saved mobs. */
   async placeChunk(chunk, executor) {
+    return this.placeColumn(chunk, executor);
+  }
+  /**
+   * Replaces parsed columns in input order, then refreshes neighboring geometry once.
+   * Duplicate coordinates retain their order. A failed column stops placement; queued refreshes finish before rejection.
+   */
+  async placeChunks(chunks) {
+    const columns = [];
+    for (const chunk of chunks) {
+      const { x, z } = chunk ?? {};
+      if (![x, z].every(Number.isSafeInteger)) {
+        throw new RangeError("Chunk column coordinates must be safe integers");
+      }
+      const sections = Array.from(chunk.sections, (section) => {
+        const { y } = section ?? {};
+        if (!Number.isSafeInteger(y)) throw new RangeError("Chunk section coordinates must be safe integers");
+        return { ...section, y };
+      });
+      columns.push({ ...chunk, x, z, sections });
+    }
+    if (!columns.length) return;
+    await this.culling;
+    let failed = false, failure, sliceStart = performance.now();
+    try {
+      for (const column of columns) {
+        await this.placeColumn(column, void 0, true);
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
+        }
+      }
+    } catch (error) {
+      failed = true;
+      failure = error;
+    } finally {
+      try {
+        const failures = await this.refreshBiomes(true);
+        if (failures.size) log19.warn("Failed to refresh biome colors", failures.values().next().value);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+      try {
+        await this.updateCulling([]);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    if (failed) throw failure;
+  }
+  async placeColumn(chunk, executor, deferCulling = false) {
     if (![chunk.x, chunk.z].every(Number.isSafeInteger)) {
       throw new RangeError("Chunk column coordinates must be safe integers");
     }
@@ -19006,7 +19061,7 @@ var MineRenderWorld = class {
           } finally {
             this.markSectionChanged(target);
           }
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -19029,9 +19084,12 @@ var MineRenderWorld = class {
       await placeEntities?.();
     } finally {
       this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-      const failures = await this.refreshBiomes();
-      if (failures.size) log19.warn("Failed to refresh biome colors", failures.values().next().value);
-      await this.updateCulling([...changes.values()]);
+      if (deferCulling) await this.updateCulling([...changes.values()], true);
+      else {
+        const failures = await this.refreshBiomes();
+        if (failures.size) log19.warn("Failed to refresh biome colors", failures.values().next().value);
+        await this.updateCulling([...changes.values()]);
+      }
     }
   }
   /**
@@ -19061,7 +19119,7 @@ var MineRenderWorld = class {
       for (const { x, z } of columns.values()) {
         this.entities?.clearColumn(x, z);
         await this.clearChunkColumn(x, z);
-        if (performance.now() - sliceStart > 8) {
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
           await yieldToEventLoop();
           sliceStart = performance.now();
         }
@@ -19200,15 +19258,25 @@ var MineRenderWorld = class {
               for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
               await chunk.refreshLight(indices === "all" ? void 0 : indices);
               chunk.refreshAmbientOcclusion(this._ambientOcclusion);
-              if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+              if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
                 await yieldToEventLoop();
                 sliceStart = performance.now();
               }
             }
-            const builds = await Promise.allSettled([...batch.keys()].map(async (chunk) => {
-              await chunk.rebuildSectionMesh();
-              batch.delete(chunk);
-            }));
+            const pending = [];
+            for (const chunk of [...batch.keys()]) {
+              const build = (async () => {
+                await chunk.rebuildSectionMesh();
+                batch.delete(chunk);
+              })();
+              void build.catch(() => void 0);
+              pending.push(build);
+              if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+                await yieldToEventLoop();
+                sliceStart = performance.now();
+              }
+            }
+            const builds = await Promise.allSettled(pending);
             const failure = builds.find((result) => result.status === "rejected");
             if (failure?.status === "rejected") throw failure.reason;
           } catch (error) {
@@ -19651,6 +19719,9 @@ _SectionWorker.initialized = false;
 var SectionWorker = _SectionWorker;
 
 // src/world/SectionMesh.ts
+var BLOCK_SIZE = 16;
+var QUAD_VERTICES = 4;
+var QUAD_INDICES = 6;
 var templateCache = /* @__PURE__ */ new WeakMap();
 var WATER_TINT = new import_three46.Color(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids, lighting) {
@@ -19687,8 +19758,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       if (!data) {
         const indices = template.geometry.getIndex();
         const position = template.geometry.getAttribute("position");
-        const quads = indices.count / 6;
-        if (indices.count % 6 !== 0 || position.count !== quads * 4) {
+        const quads = indices.count / QUAD_INDICES;
+        if (indices.count % QUAD_INDICES !== 0 || position.count !== quads * QUAD_VERTICES) {
           throw new RangeError("Section template geometry must hold four vertices and six indices per quad");
         }
         data = {
@@ -19698,8 +19769,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           uvs: new Float32Array(quads * 8),
           uvBounds: new Float32Array(quads * 16),
           colors: new Float32Array(quads * 12),
-          shade: new Float32Array(quads * 4),
-          indices: new Uint16Array(quads * 6),
+          shade: new Float32Array(quads * QUAD_VERTICES),
+          indices: new Uint16Array(quads * QUAD_INDICES),
           cullFaces: new Uint8Array(template.cullFaces),
           biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
           atlas: 0,
@@ -19711,7 +19782,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
         const bounds = template.geometry.getAttribute("uvBounds");
         const color2 = template.geometry.getAttribute("color");
         const shade = template.geometry.getAttribute("shade");
-        for (let vertex = 0; vertex < quads * 4; vertex++) {
+        for (let vertex = 0; vertex < quads * QUAD_VERTICES; vertex++) {
           data.positions.set([position.getX(vertex), position.getY(vertex), position.getZ(vertex)], vertex * 3);
           data.normals.set([normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex)], vertex * 3);
           data.uvs.set([uv.getX(vertex), uv.getY(vertex)], vertex * 2);
@@ -19724,7 +19795,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           data.colors.set([color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1], vertex * 3);
           data.shade[vertex] = shade?.getX(vertex) ?? 1;
         }
-        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - 4 * Math.floor(i2 / 6);
+        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - QUAD_VERTICES * Math.floor(i2 / QUAD_INDICES);
         templateCache.set(template, data);
       }
       id = input.templateData.length;
@@ -19757,6 +19828,54 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
   }
   return { input, atlases: atlases2 };
 }
+function sortTransparentQuads(mesh) {
+  const index = mesh.geometry.getIndex();
+  if (index.count <= QUAD_INDICES) return;
+  index.setUsage(import_three46.DynamicDrawUsage);
+  const count = index.count / QUAD_INDICES;
+  let source, centers, depths, order;
+  const view = new import_three46.Matrix4(), localCamera = new import_three46.Vector3(), key = new import_three46.Vector3(), previous = new import_three46.Vector3();
+  let previousOrthographic;
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    localCamera.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(view.copy(mesh.matrixWorld).invert());
+    const orthographic = !!camera.isOrthographicCamera;
+    if (orthographic) {
+      view.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
+      key.set(view.elements[2], view.elements[6], view.elements[10]);
+    } else {
+      key.copy(localCamera).divideScalar(BLOCK_SIZE).floor();
+    }
+    if (orthographic === previousOrthographic && key.equals(previous)) return;
+    previous.copy(key);
+    previousOrthographic = orthographic;
+    if (!centers) {
+      source = new Uint32Array(index.array);
+      centers = new Float32Array(count * 3);
+      depths = new Float32Array(count);
+      order = Uint32Array.from({ length: count }, (_, quad) => quad);
+      const positions = mesh.geometry.getAttribute("position");
+      for (let quad = 0; quad < count; quad++) {
+        for (let axis = 0; axis < 3; axis++) {
+          let center = 0;
+          for (let corner = 0; corner < QUAD_VERTICES; corner++) center += positions.getComponent(quad * QUAD_VERTICES + corner, axis);
+          centers[quad * 3 + axis] = center / QUAD_VERTICES;
+        }
+      }
+    }
+    for (let quad = 0; quad < count; quad++) {
+      const x = centers[quad * 3], y = centers[quad * 3 + 1], z = centers[quad * 3 + 2];
+      depths[quad] = orthographic ? key.x * x + key.y * y + key.z * z : -((x - localCamera.x) ** 2 + (y - localCamera.y) ** 2 + (z - localCamera.z) ** 2);
+    }
+    order.sort((a, b) => depths[a] - depths[b] || a - b);
+    if (!order.some((quad, offset) => index.array[offset * QUAD_INDICES] !== source[quad * QUAD_INDICES])) return;
+    for (let offset = 0; offset < count; offset++) {
+      for (let indexOffset = 0; indexOffset < QUAD_INDICES; indexOffset++) {
+        index.array[offset * QUAD_INDICES + indexOffset] = source[order[offset] * QUAD_INDICES + indexOffset];
+      }
+    }
+    index.needsUpdate = true;
+  };
+}
 var SectionMesh = class _SectionMesh extends import_three46.Group {
   constructor() {
     super(...arguments);
@@ -19766,7 +19885,11 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
   /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
   getBlockIndex(hit) {
     if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
-    return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
+    const mesh = hit.object;
+    const owners = this.blockIndices.get(mesh);
+    if (!owners) return void 0;
+    const vertex = mesh.geometry.getIndex().getX(hit.faceIndex * 3);
+    return owners[Math.floor(vertex / QUAD_VERTICES)];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
   static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -19802,13 +19925,14 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
       material.side = import_three46.FrontSide;
       if (page.layer === 2) {
+        material.depthWrite = !material.transparent;
         material.side = import_three46.DoubleSide;
         material.forceSinglePass = true;
-        material.depthWrite = !material.transparent;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new import_three46.Mesh(geometry, material);
+      if (transparent) sortTransparentQuads(mesh);
       section.add(mesh);
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
@@ -20611,6 +20735,7 @@ var Chunk = class _Chunk {
 };
 
 // src/world/WorldStreamer.ts
+var MAX_PREFETCHED_COLUMNS = 4;
 var WorldStreamer = class {
   constructor(world, source, options = {}) {
     this.world = world;
@@ -20620,6 +20745,7 @@ var WorldStreamer = class {
     this.missing = /* @__PURE__ */ new Map();
     this.failed = /* @__PURE__ */ new Map();
     this.desired = [];
+    this.reads = /* @__PURE__ */ new Map();
     this.disposed = false;
     this.loadRadius = options.loadRadius ?? 2;
     this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);
@@ -20664,6 +20790,12 @@ var WorldStreamer = class {
       if (this.loading && !this.within(this.loading.position, this.loadRadius)) {
         this.loading.controller.abort();
       }
+      for (const [key, read] of this.reads) {
+        if (!this.within(read.position, this.loadRadius)) {
+          read.controller.abort();
+          if (read.ready) this.reads.delete(key);
+        }
+      }
     }
     return this.running ?? (this.running = Promise.resolve().then(() => this.drain()));
   }
@@ -20684,8 +20816,11 @@ var WorldStreamer = class {
     this.desired = [];
     this.center = void 0;
     this.loading?.controller.abort();
+    for (const read of this.reads.values()) read.controller.abort();
     return this.disposal ?? (this.disposal = Promise.resolve().then(async () => {
       await this.running?.catch(() => void 0);
+      await Promise.all([...this.reads.values()].map((read) => read.promise));
+      this.reads.clear();
       try {
         await this.unloadMany([...this.owned.values()]);
       } finally {
@@ -20711,6 +20846,10 @@ var WorldStreamer = class {
           await this.unloadMany(obsolete);
           continue;
         }
+        if (this.world.placeChunks) {
+          if (await this.placeReadyChunks()) continue;
+          return;
+        }
         const position = this.desired.find((position2) => this.needsLoad(position2));
         if (!position) return;
         let chunk;
@@ -20733,26 +20872,105 @@ var WorldStreamer = class {
           continue;
         }
         this.owned.set(this.key(position), position);
+        await this.placeOwnedColumns([position], () => this.world.placeChunk(chunk));
+      }
+    } finally {
+      for (const [key, read] of this.reads) {
+        read.controller.abort();
+        if (read.ready) this.reads.delete(key);
+      }
+      this.running = void 0;
+    }
+  }
+  fillReadSlots() {
+    while (!this.disposed && this.reads.size < MAX_PREFETCHED_COLUMNS) {
+      const position = this.desired.find((position2) => this.needsLoad(position2) && !this.reads.has(this.key(position2)));
+      if (!position) return;
+      const key = this.key(position);
+      const read = {
+        position,
+        controller: new AbortController(),
+        promise: Promise.resolve(),
+        ready: false,
+        failed: false
+      };
+      this.reads.set(key, read);
+      read.promise = (async () => {
         try {
-          await this.world.placeChunk(chunk);
-          this.loaded.set(this.key(position), position);
+          read.chunk = await this.source.getChunk(position.x, position.z, read.controller.signal);
+          if (read.chunk) this.validateChunk(read.chunk, position);
         } catch (error) {
-          try {
-            await this.unloadMany([position]);
-          } catch (cleanupError) {
-            const failure = error instanceof Error ? error : new Error(String(error));
-            try {
-              Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
-            } catch {
-              throw Object.assign(new Error(failure.message), { cause: cleanupError });
-            }
-            throw failure;
+          read.failed = true;
+          read.error = error;
+        } finally {
+          read.ready = true;
+          if (read.controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) {
+            this.reads.delete(key);
           }
-          throw error;
+        }
+      })();
+    }
+  }
+  /** Places only the ready prefix, so later source reads cannot delay the nearest ready column. */
+  async placeReadyChunks() {
+    this.fillReadSlots();
+    const position = this.desired.find((position2) => this.needsLoad(position2));
+    if (!position) {
+      if (!this.reads.size) return false;
+      await Promise.all([...this.reads.values()].map((read) => read.promise));
+      return true;
+    }
+    const head = this.reads.get(this.key(position));
+    if (!head) {
+      for (let index = this.desired.length - 1; index >= 0; index--) {
+        const key = this.key(this.desired[index]);
+        if (this.reads.get(key)?.ready) {
+          this.reads.delete(key);
+          return true;
         }
       }
-    } finally {
-      this.running = void 0;
+      await Promise.race([...this.reads.values()].map((read) => read.promise));
+      return true;
+    }
+    if (!head.ready) {
+      await head.promise;
+      return true;
+    }
+    const chunks = [], positions = [];
+    for (const desired of this.desired) {
+      if (!this.needsLoad(desired)) continue;
+      const key = this.key(desired), read = this.reads.get(key);
+      if (!read?.ready) break;
+      this.reads.delete(key);
+      if (read.failed) this.failed.set(key, { ...desired, error: read.error });
+      else if (!read.chunk) this.missing.set(key, desired);
+      else {
+        chunks.push(read.chunk);
+        positions.push(desired);
+      }
+    }
+    if (!chunks.length) return true;
+    for (const position2 of positions) this.owned.set(this.key(position2), position2);
+    await this.placeOwnedColumns(positions, () => this.world.placeChunks(chunks));
+    return true;
+  }
+  async placeOwnedColumns(positions, place) {
+    try {
+      await place();
+      for (const position of positions) this.loaded.set(this.key(position), position);
+    } catch (error) {
+      try {
+        await this.unloadMany(positions);
+      } catch (cleanupError) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        try {
+          Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+        } catch {
+          throw Object.assign(new Error(failure.message), { cause: cleanupError });
+        }
+        throw failure;
+      }
+      throw error;
     }
   }
   needsLoad(position) {