minerender 2.1.0-alpha.128 → 2.1.0-alpha.129

package/dist/bundle.js

@@ -41476,6 +41476,10 @@ void main() {
       init_esm2();
       init_esm();
       _Caching = class _Caching {
+        /** Changes when shared assets are cleared, so derived caches can discard their old values. */
+        static get generation() {
+          return this._generation;
+        }
         static createAssetCache() {
           return Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
         }
@@ -41511,6 +41515,7 @@ void main() {
         }
         /** Invalidates in-memory entries so later lookups reload them. Persisted entries are retained. */
         static clear() {
+          this._generation++;
           for (const cache of this.all) {
             cache.invalidateAll();
           }
@@ -41522,6 +41527,7 @@ void main() {
          * Use {@link shutdown} to also stop requests and the shared Ticker.
          */
         static end() {
+          this._generation++;
           for (const cache of this.all) {
             cache.invalidateAll();
             cache.end();
@@ -41533,6 +41539,7 @@ void main() {
           };
         }
       };
+      _Caching._generation = 0;
       _Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
       _Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
       _Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
@@ -107734,18 +107741,23 @@ gl_FragDepth=readDepth(vUv);
         return this.template(variant, choice, tints);
       }));
     }
-    /** Resolves section templates for one tint palette, with a synchronous weighted choice for each cell. */
-    async prepareState(blockState3, properties = {}, biomeColor) {
+    /** Resolves shared templates; dynamic biome tints are supplied on section placements instead of cached geometry. */
+    async prepareState(blockState3, properties = {}, biomeColor, dynamicBiomeTint = false) {
       const prepared = await this.state(blockState3, properties);
       if (!prepared) return void 0;
       let color3;
       const resolveColor = typeof biomeColor === "function" ? () => color3 ?? (color3 = biomeColor()) : biomeColor;
       const templates = /* @__PURE__ */ new Map();
+      const source = dynamicBiomeTint && await BlockTints.biomeSource(blockState3.key);
       await Promise.all([...prepared.choices].map(async ([variant, choice]) => {
         const tints = await BlockTints.get(blockState3.key, prepared.state, choice.model, void 0, resolveColor);
-        templates.set(variant, await this.template(variant, choice, tints));
+        const biomeTints = source ? await BlockTints.get(blockState3.key, prepared.state, choice.model, void 0, 16777215) : void 0;
+        templates.set(variant, await this.template(variant, choice, tints, biomeTints));
       }));
-      return { pick: (position) => prepared.groups.map((group) => templates.get(BlockStateResolver.choose(group, position))) };
+      return {
+        pick: (position) => prepared.groups.map((group) => templates.get(BlockStateResolver.choose(group, position))),
+        biomeTint: source ? [...templates.values()].some((template) => template.biomeTint?.some((value) => value === 1)) || void 0 : void 0
+      };
     }
     async state(blockState3, properties) {
       let states = this.states.get(blockState3);
@@ -107788,10 +107800,10 @@ gl_FragDepth=readDepth(vUv);
       }
       return { state, groups, choices: prepared };
     }
-    async template(variant, { model, atlas, rotation }, tints) {
+    async template(variant, { model, atlas, rotation }, tints, biomeTints) {
       let models = this.models.get(model);
       if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
-      const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
+      const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints, biomeTints]);
       return cached(models, key, async () => {
         const object4 = new SectionModel(model, {
           instanceMeshes: false,
@@ -107805,11 +107817,13 @@ gl_FragDepth=readDepth(vUv);
         object4.clear();
         const keep = [];
         const cullFaces = [];
+        const biomeTint = biomeTints ? [] : void 0;
         for (const element of atlas.model.elements) {
           for (const face of CUBE_FACES) {
             const data = element.faces[face];
             keep.push(data !== void 0);
             if (!data) continue;
+            biomeTint?.push(Number(data.tintindex !== void 0 && biomeTints?.[data.tintindex] !== void 0));
             const local = CUBE_FACES.findIndex((name2) => name2 === data.cullface);
             if (local < 0) {
               cullFaces.push(0);
@@ -107825,6 +107839,7 @@ gl_FragDepth=readDepth(vUv);
           geometry,
           atlas,
           cullFaces: new Uint8Array(cullFaces),
+          biomeTint: biomeTint?.some(Boolean) ? new Uint8Array(biomeTint) : void 0,
           occludes: ModelCulling.isOpaqueFullCube(atlas) && ModelCulling.toLocalMask(63, rotation) === 63,
           layer: atlas.hasTranslucency ? 1 : 0,
           ambientOcclusion: model.ambientocclusion !== false
@@ -108063,6 +108078,135 @@ gl_FragDepth=readDepth(vUv);
   // src/world/MineRenderWorld.ts
   init_FluidQuads();
 
+  // src/world/_biomes/BiomeBlend.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_AssetKey();
+  init_AssetLoader();
+  init_Caching();
+  var MAX_TILES = 256;
+  function validateBiomeBlendRadius(radius) {
+    if (!Number.isInteger(radius) || radius < 0 || radius > 7) {
+      throw new RangeError("biomeBlendRadius must be an integer from 0 to 7");
+    }
+  }
+  var BiomeBlend = class {
+    constructor(biomeAt, radius) {
+      this.biomeAt = biomeAt;
+      this.tiles = /* @__PURE__ */ new Map();
+      this.generation = Caching.generation;
+      validateBiomeBlendRadius(radius);
+      this._radius = radius;
+    }
+    get radius() {
+      return this._radius;
+    }
+    clear() {
+      this.tiles.clear();
+    }
+    invalidateColumn(x4, z4) {
+      for (const [key, tile] of this.tiles) {
+        if (Math.abs(tile.x - x4) <= 1 && Math.abs(tile.z - z4) <= 1) this.tiles.delete(key);
+      }
+    }
+    async getColor(kind, origin, position) {
+      const [x4, y5, z4] = position;
+      const biome = this.biomeAt(x4, y5, z4);
+      if (biome === void 0) return void 0;
+      if (this.generation !== Caching.generation) {
+        this.clear();
+        this.generation = Caching.generation;
+      }
+      const tileX = Math.floor(x4 / 16), tileZ = Math.floor(z4 / 16), quartY = Math.floor(y5 / 4);
+      const root = origin?.root ?? AssetLoader.ROOT;
+      const key = JSON.stringify([root, AssetLoader.persistentScope, kind, this._radius, tileX, quartY, tileZ]);
+      let tile = this.tiles.get(key);
+      if (tile) {
+        this.tiles.delete(key);
+        this.tiles.set(key, tile);
+      } else {
+        const snapshot = new AssetKey("minecraft", "", void 0, void 0, "assets", ".json", root);
+        const colors = this.buildTile(kind, snapshot, tileX, quartY, tileZ, this._radius).then((result2) => {
+          if (!result2.complete && this.tiles.get(key)?.colors === colors) this.tiles.delete(key);
+          return result2;
+        }, (error2) => {
+          if (this.tiles.get(key)?.colors === colors) this.tiles.delete(key);
+          throw error2;
+        });
+        tile = { x: tileX, z: tileZ, colors };
+        this.tiles.set(key, tile);
+        if (this.tiles.size > MAX_TILES) this.tiles.delete(this.tiles.keys().next().value);
+      }
+      const result = await tile.colors;
+      if (result.failures.has(biome)) throw result.failures.get(biome);
+      const color3 = result.colors[(z4 - tileZ * 16) * 16 + x4 - tileX * 16];
+      return color3 === -1 ? void 0 : color3;
+    }
+    async buildTile(kind, origin, tileX, quartY, tileZ, radius) {
+      const size = 16 + radius * 2, stride = size + 1;
+      const startX = tileX * 16 - radius, startZ = tileZ * 16 - radius;
+      const quartX = Math.floor(startX / 4), quartZ = Math.floor(startZ / 4);
+      const quartSize = Math.floor((startX + size - 1) / 4) - quartX + 1;
+      const ids = new Array(quartSize * quartSize);
+      const biomes = /* @__PURE__ */ new Map();
+      for (let z4 = 0; z4 < quartSize; z4++) {
+        for (let x4 = 0; x4 < quartSize; x4++) {
+          const id = this.biomeAt((quartX + x4) * 4, quartY * 4, (quartZ + z4) * 4);
+          ids[z4 * quartSize + x4] = id;
+          if (id !== void 0 && !biomes.has(id)) {
+            biomes.set(id, (async () => {
+              const swamp = kind === "grass" && (await Biomes.get(id, origin))?.effects.grass_color_modifier === "swamp";
+              return { color: swamp ? void 0 : await Biomes.getColor(id, kind, origin), swamp };
+            })());
+          }
+        }
+      }
+      const failures = /* @__PURE__ */ new Map();
+      const loaded = new Map(await Promise.all([...biomes].map(async ([id, color3]) => {
+        try {
+          return [id, await color3];
+        } catch (error2) {
+          failures.set(id, error2);
+          return [id, { color: void 0, swamp: false }];
+        }
+      })));
+      const complete = [...loaded.values()].every((value) => value.swamp || value.color !== void 0);
+      const samples = new Int32Array(size * size).fill(-1);
+      const sums = Array.from({ length: 4 }, () => new Uint32Array(stride * stride));
+      for (let z4 = 0; z4 < size; z4++) {
+        const row = [0, 0, 0, 0];
+        for (let x4 = 0; x4 < size; x4++) {
+          const id = ids[(Math.floor((startZ + z4) / 4) - quartZ) * quartSize + Math.floor((startX + x4) / 4) - quartX];
+          const value = id === void 0 ? void 0 : loaded.get(id);
+          const color3 = value?.swamp ? swampGrassColor(startX + x4, startZ + z4) : value?.color;
+          if (color3 !== void 0) {
+            samples[z4 * size + x4] = color3;
+            row[0] += color3 >> 16 & 255;
+            row[1] += color3 >> 8 & 255;
+            row[2] += color3 & 255;
+            row[3]++;
+          }
+          for (let channel = 0; channel < 4; channel++) {
+            sums[channel][(z4 + 1) * stride + x4 + 1] = sums[channel][z4 * stride + x4 + 1] + row[channel];
+          }
+        }
+      }
+      const colors = new Int32Array(256).fill(-1), width = radius * 2 + 1;
+      for (let z4 = 0; z4 < 16; z4++) {
+        for (let x4 = 0; x4 < 16; x4++) {
+          if (samples[(z4 + radius) * size + x4 + radius] === -1) continue;
+          const topLeft = z4 * stride + x4, topRight = topLeft + width;
+          const bottomLeft = (z4 + width) * stride + x4, bottomRight = bottomLeft + width;
+          const sum = (values) => values[bottomRight] - values[bottomLeft] - values[topRight] + values[topLeft];
+          const count = sum(sums[3]);
+          if (count) colors[z4 * 16 + x4] = Math.floor(sum(sums[0]) / count) << 16 | Math.floor(sum(sums[1]) / count) << 8 | Math.floor(sum(sums[2]) / count);
+        }
+      }
+      return { colors, complete, failures };
+    }
+  };
+
   // src/world/WorldLight.ts
   init_dirname();
   init_buffer2();
@@ -108132,12 +108276,17 @@ gl_FragDepth=readDepth(vUv);
       this.lightValidity = /* @__PURE__ */ new Map();
       this.highestSkySection = /* @__PURE__ */ new Map();
       this.ambientOcclusionPending = false;
+      this.pendingBiomes = /* @__PURE__ */ new Map();
       this.pendingCulling = /* @__PURE__ */ new Map();
       if (options.savedLighting && !options.sectionMeshing) throw new TypeError("savedLighting requires sectionMeshing");
       if (options.ambientOcclusion && !options.sectionMeshing) throw new TypeError("ambientOcclusion requires sectionMeshing");
       if (options.ambientLight !== void 0 && (!Number.isFinite(options.ambientLight) || options.ambientLight < 0 || options.ambientLight > 1)) {
         throw new RangeError("ambientLight must be a number from 0 to 1");
       }
+      this._biomeBlendRadius = options.biomeBlendRadius ?? 0;
+      validateBiomeBlendRadius(this._biomeBlendRadius);
+      if (this._biomeBlendRadius > 0 && !options.sectionMeshing) throw new TypeError("biomeBlendRadius requires sectionMeshing");
+      if (this._biomeBlendRadius) this.biomeBlend = new BiomeBlend((x4, y5, z4) => this.getBiomeAt(x4, y5, z4), this._biomeBlendRadius);
       this.scene = scene;
       this.savedLighting = options.savedLighting ?? false;
       this.ambientLight = options.ambientLight ?? 0;
@@ -108178,6 +108327,65 @@ gl_FragDepth=readDepth(vUv);
       await this.updateCulling([]);
       this.ambientOcclusionPending = false;
     }
+    /** Horizontal biome-color sampling radius, from 0 to 7 blocks. Zero disables blending. */
+    get biomeBlendRadius() {
+      return this._biomeBlendRadius;
+    }
+    /** Refreshes loaded grass, foliage, and water colors without reloading their source chunks. */
+    async setBiomeBlendRadius(radius) {
+      validateBiomeBlendRadius(radius);
+      if (radius > 0 && !this.sectionModels) throw new TypeError("biomeBlendRadius requires sectionMeshing");
+      if (radius !== this._biomeBlendRadius) {
+        this._biomeBlendRadius = radius;
+        this.biomeBlend?.clear();
+        this.biomeBlend = radius ? new BiomeBlend((x4, y5, z4) => this.getBiomeAt(x4, y5, z4), radius) : void 0;
+        for (const chunk of this._chunks.values()) this.pendingBiomes.set(chunk, void 0);
+      }
+      const failures = await this.refreshBiomes();
+      if (failures.size) throw failures.values().next().value;
+    }
+    markBiomesChanged(x4, z4, y5, includeColumn = true) {
+      const queued = [];
+      if (!this.biomeBlend) return queued;
+      this.biomeBlend.invalidateColumn(x4, z4);
+      for (const chunk of this._chunks.values()) {
+        if (Math.abs(chunk.x - x4) > 1 || Math.abs(chunk.z - z4) > 1 || !includeColumn && chunk.x === x4 && chunk.z === z4 || y5 !== void 0 && chunk.y !== y5 && chunk.y !== y5 + 1) continue;
+        queued.push(chunk);
+        if (!this.pendingBiomes.has(chunk)) this.pendingBiomes.set(chunk, []);
+        const columns = this.pendingBiomes.get(chunk);
+        if (columns && !columns.some((column) => column.x === x4 && column.z === z4)) columns.push({ x: x4, z: z4 });
+      }
+      return queued;
+    }
+    async refreshBiomes() {
+      if (this.biomeRefreshing) await this.biomeRefreshing;
+      if (!this.pendingBiomes.size) return /* @__PURE__ */ new Map();
+      return this.biomeRefreshing ?? (this.biomeRefreshing = Promise.resolve().then(async () => {
+        const failures = /* @__PURE__ */ new Map();
+        const batch = [...this.pendingBiomes.keys()];
+        let sliceStart = performance.now();
+        try {
+          for (const chunk of batch) {
+            const columns = this.pendingBiomes.get(chunk);
+            this.pendingBiomes.delete(chunk);
+            if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) !== chunk) continue;
+            try {
+              await chunk.refreshBiomes(columns);
+            } catch (error2) {
+              failures.set(chunk, error2);
+              if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
+            }
+            if (performance.now() - sliceStart > 8) {
+              await yieldToEventLoop();
+              sliceStart = performance.now();
+            }
+          }
+          return failures;
+        } finally {
+          this.biomeRefreshing = void 0;
+        }
+      }));
+    }
     getBlockAt(posOrX, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -108413,6 +108621,9 @@ gl_FragDepth=readDepth(vUv);
         }
         await placeEntities?.();
       } finally {
+        this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
+        const failures = await this.refreshBiomes();
+        if (failures.size) console.warn("Failed to refresh biome colors", failures.values().next().value);
         await this.updateCulling([...changes.values()]);
       }
     }
@@ -108429,11 +108640,14 @@ gl_FragDepth=readDepth(vUv);
       try {
         await this.clearChunkColumn(x4, z4);
       } finally {
+        const failures = await this.refreshBiomes();
+        if (failures.size) console.warn("Failed to refresh biome colors", failures.values().next().value);
         await this.updateCulling([]);
       }
     }
     async clearChunkColumn(x4, z4) {
       this.biomes.delete(`${x4}_${z4}`);
+      this.markBiomesChanged(x4, z4, void 0, false);
       if (this.savedLighting) {
         for (const y5 of this.light.get(`${x4}_${z4}`)?.keys() ?? []) this.markSectionChanged({ x: x4, y: y5, z: z4 });
       }
@@ -108444,6 +108658,7 @@ gl_FragDepth=readDepth(vUv);
       for (const [key, section] of previous) {
         this._chunks.delete(key);
         this.pendingCulling.delete(section);
+        this.pendingBiomes.delete(section);
         await section.clear(false);
         this.markSectionChanged(section);
       }
@@ -108478,6 +108693,8 @@ gl_FragDepth=readDepth(vUv);
       const chunks = [...this._chunks.values()];
       this._chunks.clear();
       this.biomes.clear();
+      this.biomeBlend?.clear();
+      this.pendingBiomes.clear();
       this.light.clear();
       this.lightValidity.clear();
       this.highestSkySection.clear();
@@ -108596,8 +108813,14 @@ gl_FragDepth=readDepth(vUv);
               column?.delete(y5);
               if (!column?.size) this.biomes.delete(columnKey);
             }
-            await chunk.refreshBiomes();
-            await this._chunks.get(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
+            if (this.biomeBlend) {
+              const queued = this.markBiomesChanged(x4, z4, y5);
+              const failures = await this.refreshBiomes();
+              for (const chunk2 of queued) if (failures.has(chunk2)) throw failures.get(chunk2);
+            } else {
+              await chunk.refreshBiomes();
+              await this._chunks.get(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
+            }
           },
           this.savedLighting ? (x5, y6, z5) => this.lightLevelAt(x5, y6, z5) : void 0,
           async () => {
@@ -108614,7 +108837,8 @@ gl_FragDepth=readDepth(vUv);
               await this.updateCulling([]);
             }
           },
-          this.ambientLight
+          this.ambientLight,
+          () => this.biomeBlend
         );
         this._chunks.set(key, chunk);
       }
@@ -108745,9 +108969,10 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/SectionGeometry.ts
   function buildSectionGeometry(input) {
-    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion } = input;
+    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
     if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
+    if (biomeTints && biomeTints.length !== count * 3) throw new RangeError("Section biome tints must contain RGB for each placement");
     if (fluids && fluids.cells.length !== 5832) throw new RangeError("Section fluid cells must cover an 18\xD718\xD718 neighborhood");
     if (fluids?.waterTints && fluids.waterTints.length !== 4096 * 3) throw new RangeError("Section water tints must contain RGB for 4096 cells");
     if (light && (light.length !== 5832 || light.some((level) => level > 15 && level !== 255))) {
@@ -108762,7 +108987,7 @@ gl_FragDepth=readDepth(vUv);
     const cornerBrightness2 = ambientOcclusion ? new Float32Array(4) : void 0;
     for (const template of templateData) {
       const { quads } = template;
-      if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads) {
+      if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads || template.biomeTint && template.biomeTint.length !== quads) {
         throw new RangeError("Section template arrays do not match its quad count");
       }
     }
@@ -108872,6 +109097,7 @@ gl_FragDepth=readDepth(vUv);
           blockIndices[indexOffset / 6] = indices[entry];
           if (ambientMask) quadAmbientOcclusion(template.positions, template.normals, quad, ambientMask, cornerBrightness2);
           const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
+          const tint = biomeTints && template.biomeTint?.[quad] && !Number.isNaN(biomeTints[entry * 3]) ? entry * 3 : void 0;
           const start = vertex2;
           for (let corner = 0; corner < 4; corner++, vertex2++) {
             const source = quad * 4 + corner;
@@ -108888,9 +109114,9 @@ gl_FragDepth=readDepth(vUv);
             uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
             uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
             const factor = brightness * (ambientMask ? cornerBrightness2[corner] : 1);
-            colors[vertex2 * 3] = template.colors[source * 3] * factor;
-            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1] * factor;
-            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2] * factor;
+            colors[vertex2 * 3] = (tint === void 0 ? template.colors[source * 3] : biomeTints[tint]) * factor;
+            colors[vertex2 * 3 + 1] = (tint === void 0 ? template.colors[source * 3 + 1] : biomeTints[tint + 1]) * factor;
+            colors[vertex2 * 3 + 2] = (tint === void 0 ? template.colors[source * 3 + 2] : biomeTints[tint + 2]) * factor;
           }
           for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
         }
@@ -109014,7 +109240,11 @@ gl_FragDepth=readDepth(vUv);
       ...lighting
     };
     for (let i4 = 0; i4 < entries.length; i4++) {
-      const { index, template, cullMask } = entries[i4];
+      const { index, template, cullMask, biomeTint } = entries[i4];
+      if (biomeTint) {
+        input.biomeTints ?? (input.biomeTints = new Float32Array(entries.length * 3).fill(NaN));
+        input.biomeTints.set(biomeTint, i4 * 3);
+      }
       let id = templateIds.get(template);
       if (id === void 0) {
         let atlas = atlasIds.get(template.atlas);
@@ -109041,6 +109271,7 @@ gl_FragDepth=readDepth(vUv);
             colors: new Float32Array(quads * 12),
             indices: new Uint16Array(quads * 6),
             cullFaces: new Uint8Array(template.cullFaces),
+            biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
             atlas: 0,
             layer: template.layer,
             ambientOcclusion: template.ambientOcclusion
@@ -109185,7 +109416,7 @@ gl_FragDepth=readDepth(vUv);
   init_InstanceReference();
   var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
-    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
+    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0, biomeBlend) {
       this.onBlocksChanged = onBlocksChanged;
       this.sectionModels = sectionModels;
       this.neighborCell = neighborCell;
@@ -109194,6 +109425,7 @@ gl_FragDepth=readDepth(vUv);
       this.lightAt = lightAt;
       this.onLightCleared = onLightCleared;
       this.ambientLight = ambientLight;
+      this.biomeBlend = biomeBlend;
       this.data = new ChunkData();
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.objectBlocks = /* @__PURE__ */ new Set();
@@ -109203,6 +109435,7 @@ gl_FragDepth=readDepth(vUv);
       this.blockPosition = new Vector3();
       this.meshDirty = false;
       this.meshGeneration = 0;
+      this.blockChanges = /* @__PURE__ */ new Set();
       this.scene = scene;
       this.x = x4;
       this.y = y5;
@@ -109301,10 +109534,20 @@ gl_FragDepth=readDepth(vUv);
       return this.refreshBiomes();
     }
     /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
-    async refreshBiomes() {
+    refreshBiomes(columns) {
+      return this.changeBlocks(() => this.refreshBiomeBlocks(columns), true);
+    }
+    async refreshBiomeBlocks(columns) {
+      const blend = columns && this.biomeBlend?.();
+      const ownColumn = columns?.some((column) => column.x === this.x && column.z === this.z);
       const affected = /* @__PURE__ */ new Map();
       const blocks = [];
       for (const index of this.renderedBlocks.keys()) {
+        if (blend) {
+          if (this.objectBlocks.has(index) && !ownColumn) continue;
+          const [x4, , z4] = this.positionAt(index), radius = blend.radius;
+          if (!columns.some((column) => x4 >= column.x * 16 - radius && x4 <= column.x * 16 + 15 + radius && z4 >= column.z * 16 - radius && z4 <= column.z * 16 + 15 + radius)) continue;
+        }
         const block = this.data.get(index);
         const stateKey = ChunkData.paletteKey(block);
         let matches = affected.get(stateKey);
@@ -109319,10 +109562,32 @@ gl_FragDepth=readDepth(vUv);
         }
         if (await matches) blocks.push({ index, block });
       }
+      if (blend) {
+        const groups = /* @__PURE__ */ new Map();
+        for (const entry of blocks) {
+          const key = ChunkData.paletteKey(entry.block);
+          let group = groups.get(key);
+          if (!group) groups.set(key, group = []);
+          group.push(entry);
+        }
+        blocks.length = 0;
+        const biomes = /* @__PURE__ */ new Map();
+        for (const group of groups.values()) {
+          const { contexts, fluid } = await this.resolveState(group[0].block, group.map((entry) => entry.index), biomes);
+          for (const entry of group) {
+            const context = contexts.get(entry.index);
+            const current = this.sectionBlocks.get(entry.index)?.[0]?.biomeTint;
+            const tint = context?.tint;
+            const tintChanged = !!current !== !!tint || tint?.some((value, channel) => value !== current?.[channel]);
+            const waterChanged = fluid?.kind === "water" && (context?.waterTint ?? WATER_TINT2).some((value, channel) => Math.fround(value) !== (this.waterTints?.[entry.index * 3 + channel] ?? Math.fround(WATER_TINT2[channel])));
+            if (this.objectBlocks.has(entry.index) || tintChanged || waterChanged) blocks.push(entry);
+          }
+        }
+      }
       if (!blocks.length) return;
       const hidden = new Set(this.hiddenBlocks);
       try {
-        await this.placeBlocks(blocks);
+        await this.replaceBlocks(blocks, true);
       } finally {
         for (const index of hidden) {
           this.hiddenBlocks.add(index);
@@ -109362,6 +109627,20 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Places cells in input order and returns changed world positions without refreshing neighbors. */
     async placeBlocks(blocks) {
+      return this.changeBlocks(() => this.replaceBlocks(blocks));
+    }
+    changeBlocks(change, refreshBiomes = false) {
+      const before = refreshBiomes ? Promise.allSettled(this.blockChanges) : this.biomeChange;
+      const result = before ? before.catch(() => void 0).then(change) : change();
+      const pending = result.finally(() => {
+        this.blockChanges.delete(pending);
+        if (this.biomeChange === pending) this.biomeChange = void 0;
+      });
+      this.blockChanges.add(pending);
+      if (refreshBiomes) this.biomeChange = pending;
+      return pending;
+    }
+    async replaceBlocks(blocks, preserveDataOnFailure = false) {
       const placements = blocks.map(({ index, block }) => ({
         index,
         key: block && !ChunkData.isAir(block) ? ChunkData.paletteKey(block) : void 0,
@@ -109381,6 +109660,10 @@ gl_FragDepth=readDepth(vUv);
       const biomes = /* @__PURE__ */ new Map();
       const settled = await Promise.allSettled([...states.values()].map(({ stored, indices }) => this.resolveState(stored, indices, biomes)));
       const resolutions = new Map([...states.keys()].map((key, i4) => [key, settled[i4]]));
+      if (preserveDataOnFailure) {
+        const rejected = settled.find((result) => result.status === "rejected");
+        if (rejected?.status === "rejected") throw rejected.reason;
+      }
       const positions = [];
       let failed = false, failure;
       for (const { index, key, block } of placements) {
@@ -109418,7 +109701,7 @@ gl_FragDepth=readDepth(vUv);
           }
           const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : (context?.prepared ?? prepared)?.pick(variantPosition);
           if (templates) {
-            this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0 })));
+            this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
             this.meshDirty = true;
           } else {
             object4 = await this.scene.addBlock(blockState3, {
@@ -109437,7 +109720,11 @@ gl_FragDepth=readDepth(vUv);
           }, object: object4 });
           if (object4) this.objectBlocks.add(index);
         } catch (error2) {
-          this.data.assign(index, 0);
+          if (preserveDataOnFailure && readBlock) {
+            this.renderedBlocks.set(index, { get block() {
+              return readBlock();
+            }, object: void 0 });
+          } else this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           object4?.removeFromScene();
           if (!failed) failure = error2;
@@ -109448,7 +109735,10 @@ gl_FragDepth=readDepth(vUv);
       return positions;
     }
     /** Replaces every cell from parsed section data. The caller refreshes neighbor culling. */
-    async placeSection(data) {
+    placeSection(data) {
+      return this.changeBlocks(() => this.replaceSection(data));
+    }
+    async replaceSection(data) {
       for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
       this.sectionBlocks.clear();
       this.fluidCells.fill(0);
@@ -109495,7 +109785,7 @@ gl_FragDepth=readDepth(vUv);
           ];
           const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : (context?.prepared ?? prepared)?.pick(variantPosition);
           if (templates) {
-            this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0 })));
+            this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
             this.meshDirty = true;
           } else {
             perBlocks.push({ index, blockState: blockState3, biome: context?.biome });
@@ -109579,12 +109869,35 @@ gl_FragDepth=readDepth(vUv);
     }
     async resolveState(stored, indices, biomes) {
       const blockState3 = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
-      const perBlock = !blockState3 || !this.sectionModels || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
+      let perBlock = !blockState3 || !this.sectionModels || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
       const fluid = await getBlockFluidState(blockState3?.key, stored.properties);
       const hasBiomes = this.getBiomeAt(this.x * 16, this.y * 16, this.z * 16) !== void 0 || this.biomeAt?.(this.x * 16, this.y * 16 - 1, this.z * 16) !== void 0;
       const source = hasBiomes && blockState3 ? await BlockTints.biomeSource(blockState3.key) : void 0;
       const prepare = (color3) => perBlock || fluid?.renderModel === false ? void 0 : this.sectionModels.prepareState(blockState3, stored.properties, color3);
       const contexts = /* @__PURE__ */ new Map();
+      const blend = this.biomeBlend?.();
+      if (blend && !perBlock && blockState3 && (source || fluid?.kind === "water")) {
+        const prepared2 = fluid?.renderModel === false ? void 0 : await this.sectionModels.prepareState(blockState3, stored.properties, void 0, true);
+        if (!prepared2 && fluid?.renderModel !== false) {
+          perBlock = true;
+        } else {
+          await Promise.all(indices.map(async (index) => {
+            const position = this.biomePosition(index, blockState3, stored);
+            const biomeColor = (kind) => blend.getColor(kind, blockState3.key, position);
+            const context = {};
+            if (source && prepared2?.biomeTint) {
+              const color3 = await biomeColor(source);
+              if (color3 !== void 0) context.tint = new Color(color3).toArray();
+            }
+            if (fluid?.kind === "water") {
+              const color3 = await biomeColor("water");
+              if (color3 !== void 0 && color3 !== 4159204) context.waterTint = new Color(color3).toArray();
+            }
+            contexts.set(index, context);
+          }));
+          return { blockState: blockState3, perBlock, fluid, prepared: prepared2, contexts, stored };
+        }
+      }
       const groups = /* @__PURE__ */ new Map();
       if (blockState3 && (source || fluid?.kind === "water")) {
         for (const index of indices) {
@@ -109632,7 +109945,11 @@ gl_FragDepth=readDepth(vUv);
       this.waterTints.set(tint ?? WATER_TINT2, index * 3);
     }
     /** Changes visibility at world block coordinates while preserving the block's data. */
-    async setBlockVisibleAt(pos, visible) {
+    setBlockVisibleAt(pos, visible) {
+      const position = pos.clone();
+      return this.changeBlocks(() => this.setBlockVisibility(position, visible));
+    }
+    async setBlockVisibility(pos, visible) {
       const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
       const block = this.renderedBlocks.get(index);
       if (!block || visible === !this.hiddenBlocks.has(index)) {
@@ -109802,6 +110119,7 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
     async clear(notify = true) {
+      if (this.blockChanges.size) await Promise.allSettled(this.blockChanges);
       const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
         new Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
       )) : [];