minerender 2.1.0-alpha.115 → 2.1.0-alpha.116

package/dist/node/index.js

@@ -324,6 +324,9 @@ var init_Caching = __esm({
       static {
         this.usernameUuidCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
       }
+      static {
+        this.biomeCache = _Caching.createAssetCache();
+      }
       static createAssetCache() {
         return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
       }
@@ -353,7 +356,8 @@ var init_Caching = __esm({
           this.fontCache,
           this.bannerPatternCache,
           this.mineRenderDataCache,
-          this.usernameUuidCache
+          this.usernameUuidCache,
+          this.biomeCache
         ];
       }
       /** Invalidates in-memory entries so later lookups reload them. Persisted entries are retained. */
@@ -1731,7 +1735,7 @@ ${key}` : key, async () => {
             case "blockStates":
               return Object.values(value).every((property) => object(property) && "default" in property && Array.isArray(property.values));
             case "blockTints":
-              return ["constant", "grass", "stem", "redstone"].includes(value.source) && (value.source !== "constant" || Number.isInteger(value.color));
+              return ["constant", "grass", "stem", "redstone"].includes(value.source) && (value.source !== "constant" || Number.isInteger(value.color)) && (value.biome === void 0 || ["grass", "foliage", "dry_foliage", "water"].includes(value.biome));
             case "fluids":
               return ["water", "lava"].includes(value.kind) && typeof value.renderModel === "boolean" && (value.levelProperty === void 0 || typeof value.levelProperty === "string");
             case "dyes":
@@ -1875,15 +1879,19 @@ var init_Colormaps = __esm({
     Colormaps = class {
       /** Samples the selected resource pack's grass colormap using Minecraft's climate coordinates. */
       static async grassColor(origin, temperature = 0.5, downfall = 1) {
-        const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
+        return this.getColor("grass", origin, temperature, downfall);
+      }
+      /** Samples a resource-pack colormap at the supplied climate coordinates. */
+      static async getColor(kind, origin, temperature = 0.5, downfall = 1) {
+        const key = AssetKey.parse("textures", `minecraft:colormap/${kind}`, origin);
         const temp = Math.fround(temperature);
         const rain = Math.fround(downfall) * temp;
         const x = Math.floor((1 - temp) * 255), y = Math.floor((1 - rain) * 255);
         return await Caching.blockTintCache.get(`${key.serialize()}|${x},${y}`, async () => {
           const image = await ModelTextures.get(key);
-          if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
+          if (!image) throw new MineRenderError(`Missing ${kind} colormap: ${key.toNamespacedString()}`);
           if (image.width !== 256 || image.height !== 256) {
-            throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
+            throw new MineRenderError(`${kind} colormaps must be 256 \xD7 256 pixels`);
           }
           const [red, green, blue] = image.data.getImageData(x, y, 1, 1).data;
           return red << 16 | green << 8 | blue;
@@ -7614,6 +7622,7 @@ __export(index_node_exports, {
   BannerPatterns: () => BannerPatterns,
   BasicAssetKey: () => BasicAssetKey,
   BatchedExecutor: () => BatchedExecutor,
+  Biomes: () => Biomes,
   BlockEntities: () => BlockEntities,
   BlockObject: () => BlockObject,
   BlockStateResolver: () => BlockStateResolver,
@@ -7956,6 +7965,116 @@ init_AssetLoader();
 init_Assets();
 init_BannerPatterns();
 
+// src/assets/Biomes.ts
+init_AssetKey();
+init_AssetLoader();
+init_AssetParsers();
+init_Caching();
+init_MineRenderError();
+init_Colormaps();
+
+// src/assets/_biomes/SwampGrassColor.ts
+var permutation;
+var gradients = [[1, 1], [-1, 1], [1, -1], [-1, -1], [1, 0], [-1, 0], [1, 0], [-1, 0], [0, 1], [0, -1], [0, 1], [0, -1]];
+var skew = (Math.sqrt(3) - 1) / 2;
+var unskew = (3 - Math.sqrt(3)) / 6;
+function createPermutation() {
+  const multiplier = 0x5deece66dn, mask = (1n << 48n) - 1n;
+  let seed = 2345n ^ multiplier;
+  const next = (bits) => {
+    seed = seed * multiplier + 11n & mask;
+    return Number(seed >> BigInt(48 - bits));
+  };
+  for (let i = 0; i < 3; i++) {
+    next(26);
+    next(27);
+  }
+  const values = Uint8Array.from({ length: 256 }, (_, i) => i);
+  for (let i = 0; i < 256; i++) {
+    const bound = 256 - i;
+    let offset;
+    if ((bound & bound - 1) === 0) offset = Math.floor(bound * next(31) / 2147483648);
+    else {
+      let bits;
+      do {
+        bits = next(31);
+        offset = bits % bound;
+      } while (bits - offset + bound - 1 > 2147483647);
+    }
+    const other = i + offset;
+    [values[i], values[other]] = [values[other], values[i]];
+  }
+  return values;
+}
+function swampGrassColor(x, z) {
+  const p10 = permutation ??= createPermutation();
+  x *= 0.0225;
+  z *= 0.0225;
+  const s = (x + z) * skew;
+  const i = Math.floor(x + s), j = Math.floor(z + s);
+  const t = (i + j) * unskew;
+  const dx = x - (i - t), dz = z - (j - t);
+  const stepX = dx > dz ? 1 : 0, stepZ = 1 - stepX;
+  const corner = (gx, gz, a, b) => {
+    let falloff = 0.5 - a * a - b * b;
+    if (falloff < 0) return 0;
+    const gradient = gradients[p10[gx + p10[gz & 255] & 255] % 12];
+    falloff *= falloff;
+    return falloff * falloff * (gradient[0] * a + gradient[1] * b);
+  };
+  const noise = 70 * (corner(i, j, dx, dz) + corner(i + stepX, j + stepZ, dx - stepX + unskew, dz - stepZ + unskew) + corner(i + 1, j + 1, dx - 1 + 2 * unskew, dz - 1 + 2 * unskew));
+  return noise < -0.1 ? 5011004 : 6975545;
+}
+
+// src/assets/Biomes.ts
+var Biomes = class {
+  /** Loads a biome registry entry, or returns `undefined` when no source provides it. */
+  static async get(id, origin) {
+    if (!/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(id)) throw new MineRenderError(`Invalid biome identifier: ${id}`);
+    const [namespace, path] = id.includes(":") ? id.split(":") : ["minecraft", id];
+    const key = new AssetKey(namespace, path, "worldgen", "biome", "data", ".json", origin?.root);
+    return Caching.biomeCache.get(key.serialize(), async () => {
+      const asset2 = await AssetLoader.get(key, "json" /* JSON */);
+      if (asset2 === void 0) return void 0;
+      if (!asset2 || typeof asset2 !== "object" || Array.isArray(asset2) || !asset2.effects || typeof asset2.effects !== "object" || Array.isArray(asset2.effects)) {
+        throw new MineRenderError(`Invalid biome effects: ${id}`);
+      }
+      if (typeof asset2.temperature !== "number" || !Number.isFinite(asset2.temperature) || typeof asset2.downfall !== "number" || !Number.isFinite(asset2.downfall)) {
+        throw new MineRenderError(`Invalid biome climate: ${id}`);
+      }
+      for (const kind of ["grass", "foliage", "dry_foliage", "water"]) {
+        const color2 = asset2.effects[`${kind}_color`];
+        if (color2 !== void 0) this.parseColor(color2, id, kind);
+      }
+      const modifier = asset2.effects.grass_color_modifier;
+      if (modifier !== void 0 && modifier !== "none" && modifier !== "dark_forest" && modifier !== "swamp") {
+        throw new MineRenderError(`Invalid biome grass color modifier: ${id}`);
+      }
+      return asset2;
+    });
+  }
+  /** Returns packed sRGB, or `undefined` when the biome or requested water color is missing. */
+  static async getColor(id, kind, origin, x = 0, z = 0) {
+    const biome = await this.get(id, origin);
+    if (!biome) return void 0;
+    const rawColor = biome.effects[`${kind}_color`];
+    let color2 = rawColor === void 0 ? void 0 : this.parseColor(rawColor, id, kind);
+    if (kind === "water") return color2;
+    const modifier = kind === "grass" ? biome.effects.grass_color_modifier : void 0;
+    if (modifier === "swamp") return swampGrassColor(x, z);
+    if (color2 === void 0) {
+      const clamp = (value) => Math.max(0, Math.min(1, Math.fround(value)));
+      color2 = await Colormaps.getColor(kind, origin, clamp(biome.temperature), clamp(biome.downfall));
+    }
+    return modifier === "dark_forest" ? (color2 & 16711422) + 2634762 >> 1 : color2;
+  }
+  static parseColor(value, id, kind) {
+    if (typeof value === "string" && /^#[0-9a-fA-F]{6}$/.test(value)) return parseInt(value.slice(1), 16);
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 16777215) return value;
+    throw new MineRenderError(`Invalid biome ${kind} color: ${id}`);
+  }
+};
+
 // src/assets/BlockEntities.ts
 var import_three10 = require("three");
 init_AssetKey();
@@ -12394,8 +12513,20 @@ var BlockStateResolver = class _BlockStateResolver {
 init_Colormaps();
 init_MineRenderData();
 var BlockTints = class {
-  /** Resolves block preview colors without biome context; explicit tints take precedence. */
-  static async get(key, state, model, tints) {
+  /** Returns a block's versioned biome color source, leaving fixed-color blocks unchanged. */
+  static async biomeSource(key) {
+    const rule = key && (await MineRenderData.get("blockTints", key.root))[key.toNamespacedString()];
+    return rule ? rule.biome ?? (rule.source === "grass" ? "grass" : void 0) : void 0;
+  }
+  /** Resolves one block's biome tint at world block coordinates, without biome blending. */
+  static async getBiomeColor(key, biome, position) {
+    if (!biome) return void 0;
+    const x = position?.[0], z = position?.[2];
+    const source = await this.biomeSource(key);
+    return source ? Biomes.getColor(biome, source, key, x, z) : void 0;
+  }
+  /** Resolves used tint indices from biome or preview colors; explicit tints take precedence. */
+  static async get(key, state, model, tints, biomeColor) {
     if (!key) return tints;
     const candidates = (model.elements ?? []).flatMap((element) => Object.values(element.faces)).some((face) => face?.tintindex !== void 0 && face.tintindex >= 0 && tints?.[face.tintindex] === void 0);
     if (!candidates) return tints;
@@ -12411,8 +12542,12 @@ var BlockTints = class {
       }
     }
     if (!indices.size) return tints;
+    const source = rule.biome ?? (rule.source === "grass" ? "grass" : void 0);
+    const biome = source ? typeof biomeColor === "function" ? await biomeColor() : biomeColor : void 0;
     let color2;
-    switch (rule.source) {
+    if (biome !== void 0) {
+      color2 = biome;
+    } else switch (rule.source) {
       case "constant":
         color2 = rule.color;
         break;
@@ -12471,6 +12606,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
     this.variantPosition = options?.variantPosition ? [...options.variantPosition] : void 0;
+    this.biomePosition = options?.biomePosition ? [...options.biomePosition] : void 0;
   }
   static {
     this.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, ModelObject.DEFAULT_OPTIONS, {
@@ -12668,11 +12804,16 @@ var BlockObject = class _BlockObject extends SceneObject {
     const { FluidModelObject: FluidModelObject2, sampleFluid: sampleFluid2 } = await Promise.resolve().then(() => (init_FluidModelObject(), FluidModelObject_exports));
     this._fluidSampler = sample;
     const surface = sampleFluid2(kind, (x, y, z) => x === 0 && y === 0 && z === 0 ? { fluid: kind, level: this.fluidLevel } : sample?.(x, y, z) ?? {});
-    if (this._fluidKey === surface.key) return;
+    const tint = this.options.tints?.[0] ?? this.waterTint;
+    const fluidKey = `${surface.key}|${tint ?? "default"}`;
+    if (this._fluidKey === fluidKey) return;
     const key = new AssetKey("minecraft", `${kind}/${surface.key}`, "models", "fluid", "assets", ".json", this.blockState.key?.root);
     const replacement = await this.scene.addSceneObject(
       { key },
-      () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
+      () => new FluidModelObject2(kind, surface.sample, this.blockState.key, {
+        ...this.options,
+        tints: tint === void 0 ? this.options.tints : { ...this.options.tints, 0: tint }
+      })
     );
     const previous = this._fluidModel;
     const matrix = previous ? this.getModelMatrix(previous) : new import_three34.Matrix4().makeTranslation(...this.position.toArray());
@@ -12681,7 +12822,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._models = this._models.filter((model) => model !== previous);
     this._models.push(replacement);
     this._fluidModel = replacement;
-    this._fluidKey = surface.key;
+    this._fluidKey = fluidKey;
     this._isInstanced ||= isInstanceReference(replacement);
     this._instanceCounter = this._isInstanced ? 1 : 0;
     if (previous) this.removeModels([previous]);
@@ -12704,6 +12845,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   }
   async recreateModels() {
     this.clearModels();
+    this.waterTint = this.fluidKind === "water" && this.options.biome && this.options.tints?.[0] === void 0 ? await Biomes.getColor(this.options.biome, "water", this.blockState.key) : void 0;
     if (resolveBlockFluidState(this.blockState.key, this.state, this._fluidRules)?.renderModel === false) {
       await this.updateFluid(this._fluidSampler);
       return;
@@ -12738,7 +12880,13 @@ var BlockObject = class _BlockObject extends SceneObject {
     const model = await Models.getMerged(modelKey);
     const options = {
       ...this.options,
-      tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
+      tints: model ? await BlockTints.get(
+        this.blockState.key,
+        this.state,
+        model,
+        this.options.tints,
+        () => BlockTints.getBiomeColor(this.blockState.key, this.options.biome, this.biomePosition)
+      ) : this.options.tints,
       uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0,
       cullMask: this.options.displayPosition ? 0 : ModelCulling.toLocalMask(this._cullMask, rotation)
     };
@@ -17217,24 +17365,48 @@ var SectionModels = class {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("maxAtlasSize must be a positive integer");
   }
   /** Returns templates for the matched parts, or `undefined` when the block needs an individual render object. */
-  async get(blockState3, properties = {}, position) {
-    const variantPosition = position ? [...position] : void 0;
-    return (await this.prepareState(blockState3, properties))?.pick(variantPosition);
+  async get(blockState3, properties = {}, position, biome) {
+    const biomePosition = position ? [...position] : void 0;
+    const prepared = await this.state(blockState3, properties);
+    if (!prepared) return void 0;
+    return Promise.all(prepared.groups.map(async (group) => {
+      const variant = BlockStateResolver.choose(group, biomePosition);
+      const choice = prepared.choices.get(variant);
+      const tints = await BlockTints.get(
+        blockState3.key,
+        prepared.state,
+        choice.model,
+        void 0,
+        () => BlockTints.getBiomeColor(blockState3.key, biome, biomePosition)
+      );
+      return this.template(variant, choice, tints);
+    }));
   }
-  /** Resolves section templates once, with a synchronous weighted choice for each cell. */
-  async prepareState(blockState3, properties = {}) {
+  /** Resolves section templates for one tint palette, with a synchronous weighted choice for each cell. */
+  async prepareState(blockState3, properties = {}, biomeColor) {
+    const prepared = await this.state(blockState3, properties);
+    if (!prepared) return void 0;
+    let color2;
+    const resolveColor = typeof biomeColor === "function" ? () => color2 ??= biomeColor() : biomeColor;
+    const templates = /* @__PURE__ */ new Map();
+    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));
+    }));
+    return { pick: (position) => prepared.groups.map((group) => templates.get(BlockStateResolver.choose(group, position))) };
+  }
+  async state(blockState3, properties) {
     let states = this.states.get(blockState3);
     if (!states) this.states.set(blockState3, states = /* @__PURE__ */ new Map());
     const key = JSON.stringify(Object.entries(properties).sort(([a], [b]) => a.localeCompare(b)));
-    const prepared = await cached(states, key, () => this.prepare(blockState3, properties));
-    if (!prepared) return void 0;
-    return { pick: (position) => prepared.groups.map((group) => prepared.templates.get(BlockStateResolver.choose(group, position))) };
+    return cached(states, key, () => this.prepare(blockState3, properties));
   }
   /** Returns the shared still/flow atlas used by per-block fluid objects. */
   fluidAtlas(kind, root) {
-    return cached(this.fluidAtlases, kind, async () => {
+    const key = new AssetKey("minecraft", kind, "models", "fluid", "assets", ".json", root);
+    return cached(this.fluidAtlases, key.serialize(), async () => {
       const atlas = await UVMapper.getAtlas({
-        key: new AssetKey("minecraft", kind, "models", "fluid", "assets", ".json", root),
+        key,
         textures: { still: `minecraft:block/${kind}_still`, flow: `minecraft:block/${kind}_flow` },
         elements: []
       });
@@ -17246,64 +17418,67 @@ var SectionModels = class {
     const state = { ...await BlockStateResolver.defaults(blockState3), ...properties };
     const groups = BlockStateResolver.matching(blockState3, state);
     if (!groups.length) return void 0;
-    const templates = /* @__PURE__ */ new Map();
+    const prepared = /* @__PURE__ */ new Map();
     for (const group of groups) {
       const choices = Array.isArray(group) ? group : [group];
       if (!choices.length) return void 0;
       for (const variant of choices) {
         if (!variant.model) return void 0;
-        const model = await Models.getMerged(AssetKey.parse("models", variant.model));
+        const modelKey = AssetKey.parse("models", variant.model);
+        modelKey.root = blockState3.key?.root;
+        const model = await Models.getMerged(modelKey);
         if (!model?.elements?.length) return void 0;
         const atlas = await UVMapper.getAtlas(model);
         const rotation = BlockStateResolver.rotation(variant);
         if (!atlas || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize) return void 0;
-        const tints = await BlockTints.get(blockState3.key, state, model);
-        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 template = await cached(models, key, async () => {
-          const object4 = new SectionModel(model, {
-            instanceMeshes: false,
-            mergeMeshes: true,
-            tints,
-            uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
-          });
-          await object4.init();
-          let geometry = object4.children[0].geometry;
-          geometry.applyMatrix4(new import_three41.Matrix4().makeRotationFromEuler(rotation));
-          object4.clear();
-          const keep = [];
-          const cullFaces = [];
-          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;
-              const local = CUBE_FACES.findIndex((name) => name === data.cullface);
-              if (local < 0) {
-                cullFaces.push(0);
-                continue;
-              }
-              const normal = new import_three41.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
-              const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
-              cullFaces.push(world < 0 ? 0 : 1 << world);
-            }
-          }
-          geometry = compactQuads(geometry, keep);
-          const template2 = {
-            geometry,
-            atlas,
-            cullFaces: new Uint8Array(cullFaces),
-            occludes: ModelCulling.isOpaqueFullCube(atlas) && ModelCulling.toLocalMask(63, rotation) === 63,
-            layer: atlas.hasTranslucency ? 1 : 0
-          };
-          this.templates.add(template2);
-          return template2;
-        });
-        templates.set(variant, template);
+        prepared.set(variant, { model, atlas, rotation });
       }
     }
-    return { groups, templates };
+    return { state, groups, choices: prepared };
+  }
+  async template(variant, { model, atlas, rotation }, tints) {
+    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]);
+    return cached(models, key, async () => {
+      const object4 = new SectionModel(model, {
+        instanceMeshes: false,
+        mergeMeshes: true,
+        tints,
+        uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+      });
+      await object4.init();
+      let geometry = object4.children[0].geometry;
+      geometry.applyMatrix4(new import_three41.Matrix4().makeRotationFromEuler(rotation));
+      object4.clear();
+      const keep = [];
+      const cullFaces = [];
+      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;
+          const local = CUBE_FACES.findIndex((name) => name === data.cullface);
+          if (local < 0) {
+            cullFaces.push(0);
+            continue;
+          }
+          const normal = new import_three41.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
+          cullFaces.push(world < 0 ? 0 : 1 << world);
+        }
+      }
+      geometry = compactQuads(geometry, keep);
+      const template = {
+        geometry,
+        atlas,
+        cullFaces: new Uint8Array(cullFaces),
+        occludes: ModelCulling.isOpaqueFullCube(atlas) && ModelCulling.toLocalMask(63, rotation) === 63,
+        layer: atlas.hasTranslucency ? 1 : 0
+      };
+      this.templates.add(template);
+      return template;
+    });
   }
   /** Disposes prepared geometry and clears this world's template caches. */
   clear() {
@@ -17633,7 +17808,6 @@ var MineRenderWorld = class {
     }
     try {
       await this.clearChunkColumn(chunk.x, chunk.z);
-      let sliceStart = performance.now();
       for (const section of chunk.sections) {
         if (section.biomes) {
           const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -17647,6 +17821,9 @@ var MineRenderWorld = class {
           if (!column) this.biomes.set(key, column = /* @__PURE__ */ new Map());
           column.set(section.y, copy);
         }
+      }
+      let sliceStart = performance.now();
+      for (const section of chunk.sections) {
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
           const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -17811,18 +17988,34 @@ var MineRenderWorld = class {
     const key = this.worldPosToChunkKey(pos);
     let chunk = this._chunks.get(key);
     if (typeof chunk === "undefined") {
+      const x = Math.floor(pos.x / 16), y = Math.floor(pos.y / 16), z = Math.floor(pos.z / 16);
       chunk = new Chunk(
         this.scene,
-        Math.floor(pos.x / 16),
-        Math.floor(pos.y / 16),
-        Math.floor(pos.z / 16),
+        x,
+        y,
+        z,
         (positions) => this.updateCulling(positions),
         this.sectionModels,
-        (x, y, z) => {
-          const cx = Math.floor(x / 16), cy = Math.floor(y / 16), cz = Math.floor(z / 16);
+        (x2, y2, z2) => {
+          const cx = Math.floor(x2 / 16), cy = Math.floor(y2 / 16), cz = Math.floor(z2 / 16);
           const section = this._chunks.get(`${cx}_${cy}_${cz}`);
-          const index = (y - cy * 16) * 256 + (z - cz * 16) * 16 + x - cx * 16;
+          const index = (y2 - cy * 16) * 256 + (z2 - cz * 16) * 16 + x2 - cx * 16;
           return (section?.fluidByteIndex(index) ?? 0) | (section?.isOccludingIndex(index) ? 64 : 0);
+        },
+        (x2, y2, z2) => this.getBiomeAt(x2, y2, z2),
+        async (biomes) => {
+          if (this._chunks.get(key) !== chunk) return;
+          const columnKey = `${x}_${z}`;
+          let column = this.biomes.get(columnKey);
+          if (biomes) {
+            if (!column) this.biomes.set(columnKey, column = /* @__PURE__ */ new Map());
+            column.set(y, biomes);
+          } else {
+            column?.delete(y);
+            if (!column?.size) this.biomes.delete(columnKey);
+          }
+          await chunk.refreshBiomes();
+          await this._chunks.get(`${x}_${y + 1}_${z}`)?.refreshBiomes();
         }
       );
       this._chunks.set(key, chunk);
@@ -17877,6 +18070,7 @@ function buildSectionGeometry(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 (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");
   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) {
@@ -17954,7 +18148,9 @@ function buildSectionGeometry(input) {
           height
         });
       }
-      fluidPages.get(fluid).fluids.push({ quads, x, y, z, data });
+      const tintIndex = (x + z * 16 + y * 256) * 3;
+      const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
+      fluidPages.get(fluid).fluids.push({ quads, x, y, z, data, tint });
     }
     pages.push(...[...fluidPages.values()].sort((a, b) => Number(atlases[a.placements[0].atlas].animated) - Number(atlases[b.placements[0].atlas].animated) || a.placements[0].atlas - b.placements[0].atlas));
   }
@@ -18003,7 +18199,7 @@ function buildSectionGeometry(input) {
         for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
       }
     }
-    for (const { quads, x, y, z, data } of page.fluids) {
+    for (const { quads, x, y, z, data, tint } of page.fluids) {
       const atlas = atlases[data.atlas];
       const placement = page.placements[0];
       const mapU = (u) => (placement.x + u * atlas.width) / page.width;
@@ -18027,7 +18223,7 @@ function buildSectionGeometry(input) {
             mapU((rect[0] + rect[2]) / atlas.width),
             mapV(1 - rect[1] / atlas.height)
           ], vertex * 4);
-          colors.set(data.tint, vertex * 3);
+          colors.set(tint, vertex * 3);
         }
         outputIndices.set([start, start + 1, start + 2, start, start + 2, start + 3], indexOffset);
         indexOffset += 6;
@@ -18169,7 +18365,7 @@ function toInput(entries, maxAtlasSize, fluids) {
     input.cullMasks[i] = cullMask;
   }
   if (fluids) {
-    input.fluids = { cells: fluids.cells };
+    input.fluids = { cells: fluids.cells, waterTints: fluids.waterTints };
     for (const kind of ["water", "lava"]) {
       const atlas = fluids[kind];
       if (!atlas) continue;
@@ -18270,11 +18466,14 @@ var SectionMesh = class _SectionMesh extends import_three43.Group {
 init_FluidGeometry();
 init_FluidQuads();
 init_CubeFace();
+var WATER_TINT2 = new import_three44.Color(4159204).toArray();
 var Chunk = class _Chunk {
-  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell) {
+  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged) {
     this.onBlocksChanged = onBlocksChanged;
     this.sectionModels = sectionModels;
     this.neighborCell = neighborCell;
+    this.biomeAt = biomeAt;
+    this.onBiomesChanged = onBiomesChanged;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
     this.sectionBlocks = /* @__PURE__ */ new Map();
@@ -18299,6 +18498,56 @@ var Chunk = class _Chunk {
     const index = _Chunk.chunkPosToBlockIndex(pos);
     return this.renderedBlocks.get(index);
   }
+  getBiomeAt(posOrX, y, z) {
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three44.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three44.Vector3(...posOrX));
+    const pos = this.worldPosToChunkPos(posOrX);
+    _Chunk.chunkPosToBlockIndex(pos);
+    return this.biomeAt ? this.biomeAt(posOrX.x, posOrX.y, posOrX.z) : this.biomes?.[Math.floor(pos.x / 4) + Math.floor(pos.z / 4) * 4 + Math.floor(pos.y / 4) * 16];
+  }
+  /** Copies 64 biome IDs in x + z * 4 + y * 16 order and refreshes placed blocks. Omit the array to clear biome data. */
+  setBiomes(biomes) {
+    const copy = biomes ? [...biomes] : void 0;
+    if (copy && (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0))) {
+      throw new RangeError("Section biomes must contain 64 nonempty biome IDs");
+    }
+    if (this.onBiomesChanged) return this.onBiomesChanged(copy);
+    this.biomes = copy;
+    return this.refreshBiomes();
+  }
+  /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
+  async refreshBiomes() {
+    const affected = /* @__PURE__ */ new Map();
+    const blocks = [];
+    for (const index of this.renderedBlocks.keys()) {
+      const block = this.data.get(index);
+      const stateKey = ChunkData.paletteKey(block);
+      let matches = affected.get(stateKey);
+      if (!matches) {
+        const key = AssetKey.parse("blockstates", block.type);
+        matches = BlockStates.get(key).then(async (state) => {
+          const origin = state?.key ?? key;
+          const [source, fluid] = await Promise.all([BlockTints.biomeSource(origin), getBlockFluidState(origin, block.properties)]);
+          return !!source || fluid?.kind === "water";
+        });
+        affected.set(stateKey, matches);
+      }
+      if (await matches) blocks.push({ index, block });
+    }
+    if (!blocks.length) return;
+    const hidden = new Set(this.hiddenBlocks);
+    try {
+      await this.placeBlocks(blocks);
+    } finally {
+      for (const index of hidden) {
+        this.hiddenBlocks.add(index);
+        this.renderedBlocks.get(index)?.object?.setVisible(false);
+      }
+      const positions = blocks.map(({ index }) => new import_three44.Vector3(...this.positionAt(index)));
+      if (this.onBlocksChanged) await this.onBlocksChanged(positions);
+      else await this.rebuildSectionMesh();
+    }
+  }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
       return this.setBlockAt(new import_three44.Vector3(posOrX, yOrBlock, z), block);
@@ -18337,14 +18586,15 @@ var Chunk = class _Chunk {
         nbt: block.nbt === void 0 ? void 0 : structuredClone(block.nbt)
       } : void 0
     }));
-    const states = new Map(placements.filter(({ key }) => key !== void 0).map(({ key, block }) => [key, block]));
-    const settled = await Promise.allSettled([...states.values()].map(async (stored) => {
-      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()));
-      const fluid = await getBlockFluidState(blockState3?.key, stored.properties);
-      const prepared = perBlock || fluid?.renderModel === false ? void 0 : await this.sectionModels.prepareState(blockState3, stored.properties);
-      return { blockState: blockState3, perBlock, fluid, prepared, stored };
-    }));
+    const states = /* @__PURE__ */ new Map();
+    for (const { index, key, block } of placements) {
+      if (key === void 0) continue;
+      let state = states.get(key);
+      if (!state) states.set(key, state = { stored: block, indices: [] });
+      state.indices.push(index);
+    }
+    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, i) => [key, settled[i]]));
     const positions = [];
     let failed = false, failure;
@@ -18368,7 +18618,8 @@ var Chunk = class _Chunk {
         if (!readBlock) continue;
         const resolved = resolutions.get(key);
         if (resolved.status === "rejected") throw resolved.reason;
-        const { blockState: blockState3, perBlock, fluid, prepared, stored } = resolved.value;
+        const { blockState: blockState3, perBlock, fluid, prepared, contexts, stored } = resolved.value;
+        const context = contexts.get(index);
         if (!blockState3) {
           this.data.assign(index, 0);
           continue;
@@ -18376,9 +18627,10 @@ var Chunk = class _Chunk {
         const variantPosition = worldPos.toArray();
         if (fluid) {
           this.fluidCells[index] = (fluid.kind === "water" ? 16 : 32) | Math.min(fluid.level, 8);
+          if (fluid.kind === "water") this.setWaterTint(index, context?.waterTint);
           this.meshDirty = true;
         }
-        const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : prepared?.pick(variantPosition);
+        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.meshDirty = true;
@@ -18388,7 +18640,9 @@ var Chunk = class _Chunk {
             instanceMeshes: true,
             maxInstanceCount: 2e3,
             initialState: stored.properties,
-            variantPosition
+            variantPosition,
+            biome: context?.biome,
+            biomePosition: this.biomePosition(index, blockState3, stored)
           });
           object4.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
         }
@@ -18411,24 +18665,21 @@ var Chunk = class _Chunk {
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
     this.fluidCells.fill(0);
+    this.waterTints = void 0;
     this.renderedBlocks.clear();
     this.hiddenBlocks.clear();
     this.meshDirty = true;
     this.data.copyFrom(data);
-    const ids = /* @__PURE__ */ new Set();
+    const ids = /* @__PURE__ */ new Map();
     for (let index = 0; index < 4096; index++) {
       const id = this.data.idAt(index);
-      if (id) ids.add(id);
-    }
-    const palette = [...ids];
-    const settled = await Promise.allSettled(palette.map(async (id) => {
-      const state = this.data.stateAt(id);
-      const blockState3 = await BlockStates.get(AssetKey.parse("blockstates", state.type));
-      const perBlock = !blockState3 || !this.sectionModels || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
-      const fluid = await getBlockFluidState(blockState3?.key, state.properties);
-      const prepared = perBlock || fluid?.renderModel === false ? void 0 : await this.sectionModels.prepareState(blockState3, state.properties);
-      return { blockState: blockState3, perBlock, fluid, prepared };
-    }));
+      if (!id) continue;
+      let indices = ids.get(id);
+      if (!indices) ids.set(id, indices = []);
+      indices.push(index);
+    }
+    const palette = [...ids.keys()], biomes = /* @__PURE__ */ new Map();
+    const settled = await Promise.allSettled(palette.map((id) => this.resolveState(this.data.stateAt(id), ids.get(id), biomes)));
     const resolutions = new Map(palette.map((id, i) => [id, settled[i]]));
     const perBlocks = [];
     let failed = false, failure;
@@ -18438,24 +18689,28 @@ var Chunk = class _Chunk {
       try {
         const resolved = resolutions.get(id);
         if (resolved.status === "rejected") throw resolved.reason;
-        const { blockState: blockState3, perBlock, fluid, prepared } = resolved.value;
+        const { blockState: blockState3, perBlock, fluid, prepared, contexts } = resolved.value;
+        const context = contexts.get(index);
         if (!blockState3) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           continue;
         }
-        if (fluid) this.fluidCells[index] = (fluid.kind === "water" ? 16 : 32) | Math.min(fluid.level, 8);
+        if (fluid) {
+          this.fluidCells[index] = (fluid.kind === "water" ? 16 : 32) | Math.min(fluid.level, 8);
+          if (fluid.kind === "water") this.setWaterTint(index, context?.waterTint);
+        }
         const variantPosition = [
           this.x * 16 + index % 16,
           this.y * 16 + Math.floor(index / 256),
           this.z * 16 + Math.floor(index / 16) % 16
         ];
-        const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : prepared?.pick(variantPosition);
+        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.meshDirty = true;
         } else {
-          perBlocks.push({ index, blockState: blockState3 });
+          perBlocks.push({ index, blockState: blockState3, biome: context?.biome });
         }
         const readBlock = this.data.snapshot(index);
         this.renderedBlocks.set(index, { get block() {
@@ -18468,7 +18723,7 @@ var Chunk = class _Chunk {
         failed = true;
       }
     }
-    for (const { index, blockState: blockState3 } of perBlocks) {
+    for (const { index, blockState: blockState3, biome } of perBlocks) {
       let object4;
       try {
         object4 = await this.scene.addBlock(blockState3, {
@@ -18476,11 +18731,9 @@ var Chunk = class _Chunk {
           instanceMeshes: true,
           maxInstanceCount: 2e3,
           initialState: this.data.stateAt(this.data.idAt(index)).properties,
-          variantPosition: [
-            this.x * 16 + index % 16,
-            this.y * 16 + Math.floor(index / 256),
-            this.z * 16 + Math.floor(index / 16) % 16
-          ]
+          variantPosition: this.positionAt(index),
+          biome,
+          biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
         });
         object4.setPosition(new import_three44.Vector3(
           this.x * 256 + index % 16 * 16,
@@ -18499,6 +18752,68 @@ var Chunk = class _Chunk {
     }
     if (failed) throw failure;
   }
+  positionAt(index) {
+    return [this.x * 16 + index % 16, this.y * 16 + Math.floor(index / 256), this.z * 16 + Math.floor(index / 16) % 16];
+  }
+  biomePosition(index, blockState3, stored) {
+    const position = this.positionAt(index), name = blockState3.key?.toNamespacedString();
+    if (stored.properties?.half === "upper" && (name === "minecraft:tall_grass" || name === "minecraft:large_fern")) position[1]--;
+    return position;
+  }
+  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()));
+    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 = (color2) => perBlock || fluid?.renderModel === false ? void 0 : this.sectionModels.prepareState(blockState3, stored.properties, color2);
+    const contexts = /* @__PURE__ */ new Map();
+    const groups = /* @__PURE__ */ new Map();
+    if (blockState3 && (source || fluid?.kind === "water")) {
+      for (const index of indices) {
+        const position = this.biomePosition(index, blockState3, stored);
+        const biome = this.biomeAt ? this.biomeAt(...position) : position[1] >= this.y * 16 ? this.getBiomeAt(position) : void 0;
+        if (!biome) continue;
+        const key = JSON.stringify(source === "grass" ? [biome, position[0], position[2]] : [biome]);
+        let group = groups.get(key);
+        if (!group) groups.set(key, group = { biome, position, indices: [] });
+        group.indices.push(index);
+      }
+    }
+    const groupedCount = [...groups.values()].reduce((sum, group) => sum + group.indices.length, 0);
+    const prepared = groupedCount < indices.length ? await prepare() : void 0;
+    await Promise.all([...groups.values()].map(async ({ biome, position, indices: indices2 }) => {
+      const available = () => {
+        const key = JSON.stringify([biome, blockState3?.key?.root]);
+        let found = biomes.get(key);
+        if (!found) {
+          found = Biomes.get(biome, blockState3?.key).then((value) => value !== void 0);
+          biomes.set(key, found);
+        }
+        return found;
+      };
+      const context = { biome };
+      if (perBlock) {
+        if (!await available()) context.biome = void 0;
+      } else {
+        context.prepared = await prepare(async () => await available() ? BlockTints.getBiomeColor(blockState3?.key, biome, position) : void 0);
+        if (fluid?.kind === "water" && await available()) {
+          const color2 = await Biomes.getColor(biome, "water", blockState3?.key);
+          if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three44.Color(color2).toArray();
+        }
+      }
+      for (const index of indices2) contexts.set(index, context);
+    }));
+    return { blockState: blockState3, perBlock, fluid, prepared, contexts, stored };
+  }
+  setWaterTint(index, tint) {
+    if (!this.sectionModels || !this.waterTints && tint === void 0) return;
+    if (!this.waterTints) {
+      this.waterTints = new Float32Array(4096 * 3);
+      for (let cell = 0; cell < 4096; cell++) this.waterTints.set(WATER_TINT2, cell * 3);
+    }
+    this.waterTints.set(tint ?? WATER_TINT2, index * 3);
+  }
   /** Changes visibility at world block coordinates while preserving the block's data. */
   async setBlockVisibleAt(pos, visible) {
     const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
@@ -18602,7 +18917,7 @@ var Chunk = class _Chunk {
       if (block && !block.object) origins.set(kind, block.block.type);
     }
     if (origins.size) {
-      fluids = { cells: new Uint8Array(18 * 18 * 18) };
+      fluids = { cells: new Uint8Array(18 * 18 * 18), waterTints: this.waterTints?.slice() };
       for (let y = -1; y <= 16; y++) {
         for (let z = -1; z <= 16; z++) {
           for (let x = -1; x <= 16; x++) {
@@ -18644,8 +18959,13 @@ var Chunk = class _Chunk {
     this.renderedBlocks.clear();
     this.hiddenBlocks.clear();
     this.fluidCells.fill(0);
+    this.waterTints = void 0;
     this.data.clear();
-    if (notify) await this.onBlocksChanged?.(positions);
+    this.biomes = void 0;
+    if (notify) {
+      await this.onBiomesChanged?.(void 0);
+      await this.onBlocksChanged?.(positions);
+    }
   }
   async dispose() {
     await this.clear();
@@ -19031,6 +19351,7 @@ var NodeRenderer = class _NodeRenderer extends Renderer {
   BannerPatterns,
   BasicAssetKey,
   BatchedExecutor,
+  Biomes,
   BlockEntities,
   BlockObject,
   BlockStateResolver,