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

package/dist/bundle.js

@@ -20101,8 +20101,8 @@ var MineRender = (() => {
             width *= view.width / fullWidth;
             height *= view.height / fullHeight;
           }
-          const skew = this.filmOffset;
-          if (skew !== 0) left += near * skew / this.getFilmWidth();
+          const skew2 = this.filmOffset;
+          if (skew2 !== 0) left += near * skew2 / this.getFilmWidth();
           this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far, this.coordinateSystem, this.reversedDepth);
           this.projectionMatrixInverse.copy(this.projectionMatrix).invert();
         }
@@ -41489,7 +41489,8 @@ void main() {
             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. */
@@ -41540,6 +41541,7 @@ void main() {
       _Caching.bannerPatternCache = _Caching.createAssetCache();
       _Caching.mineRenderDataCache = _Caching.createAssetCache();
       _Caching.usernameUuidCache = Caches.builder().expireAfterWrite(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+      _Caching.biomeCache = _Caching.createAssetCache();
       Caching = _Caching;
     }
   });
@@ -43305,7 +43307,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":
@@ -43461,15 +43463,19 @@ ${key}` : key, async () => {
       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 x4 = Math.floor((1 - temp) * 255), y5 = Math.floor((1 - rain) * 255);
           return await Caching.blockTintCache.get(`${key.serialize()}|${x4},${y5}`, 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(x4, y5, 1, 1).data;
             return red << 16 | green << 8 | blue;
@@ -57531,7 +57537,7 @@ ${key}` : key, async () => {
         var base = 36;
         var tMin = 1;
         var tMax = 26;
-        var skew = 38;
+        var skew2 = 38;
         var damp2 = 700;
         var initialBias = 72;
         var initialN = 128;
@@ -57620,7 +57626,7 @@ ${key}` : key, async () => {
           ) {
             delta = floor(delta / baseMinusTMin);
           }
-          return floor(k4 + (baseMinusTMin + 1) * delta / (delta + skew));
+          return floor(k4 + (baseMinusTMin + 1) * delta / (delta + skew2));
         };
         var decode2 = function decode3(input) {
           var output = [];
@@ -95379,6 +95385,7 @@ ${shader.fragmentShader}`.replace(
     BannerPatterns: () => BannerPatterns,
     BasicAssetKey: () => BasicAssetKey,
     BatchedExecutor: () => BatchedExecutor,
+    Biomes: () => Biomes,
     BlockEntities: () => BlockEntities,
     BlockObject: () => BlockObject,
     BlockStateResolver: () => BlockStateResolver,
@@ -95841,6 +95848,122 @@ ${shader.fragmentShader}`.replace(
   init_Assets();
   init_BannerPatterns();
 
+  // src/assets/Biomes.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_AssetKey();
+  init_AssetLoader();
+  init_AssetParsers();
+  init_Caching();
+  init_MineRenderError();
+  init_Colormaps();
+
+  // src/assets/_biomes/SwampGrassColor.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 = (bits2) => {
+      seed = seed * multiplier + 11n & mask;
+      return Number(seed >> BigInt(48 - bits2));
+    };
+    for (let i4 = 0; i4 < 3; i4++) {
+      next(26);
+      next(27);
+    }
+    const values = Uint8Array.from({ length: 256 }, (_4, i4) => i4);
+    for (let i4 = 0; i4 < 256; i4++) {
+      const bound = 256 - i4;
+      let offset;
+      if ((bound & bound - 1) === 0) offset = Math.floor(bound * next(31) / 2147483648);
+      else {
+        let bits2;
+        do {
+          bits2 = next(31);
+          offset = bits2 % bound;
+        } while (bits2 - offset + bound - 1 > 2147483647);
+      }
+      const other = i4 + offset;
+      [values[i4], values[other]] = [values[other], values[i4]];
+    }
+    return values;
+  }
+  function swampGrassColor(x4, z4) {
+    const p13 = permutation ?? (permutation = createPermutation());
+    x4 *= 0.0225;
+    z4 *= 0.0225;
+    const s4 = (x4 + z4) * skew;
+    const i4 = Math.floor(x4 + s4), j4 = Math.floor(z4 + s4);
+    const t5 = (i4 + j4) * unskew;
+    const dx = x4 - (i4 - t5), dz = z4 - (j4 - t5);
+    const stepX = dx > dz ? 1 : 0, stepZ = 1 - stepX;
+    const corner = (gx, gz, a4, b4) => {
+      let falloff = 0.5 - a4 * a4 - b4 * b4;
+      if (falloff < 0) return 0;
+      const gradient = gradients[p13[gx + p13[gz & 255] & 255] % 12];
+      falloff *= falloff;
+      return falloff * falloff * (gradient[0] * a4 + gradient[1] * b4);
+    };
+    const noise = 70 * (corner(i4, j4, dx, dz) + corner(i4 + stepX, j4 + stepZ, dx - stepX + unskew, dz - stepZ + unskew) + corner(i4 + 1, j4 + 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 color3 = asset2.effects[`${kind}_color`];
+          if (color3 !== void 0) this.parseColor(color3, 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, x4 = 0, z4 = 0) {
+      const biome = await this.get(id, origin);
+      if (!biome) return void 0;
+      const rawColor = biome.effects[`${kind}_color`];
+      let color3 = rawColor === void 0 ? void 0 : this.parseColor(rawColor, id, kind);
+      if (kind === "water") return color3;
+      const modifier = kind === "grass" ? biome.effects.grass_color_modifier : void 0;
+      if (modifier === "swamp") return swampGrassColor(x4, z4);
+      if (color3 === void 0) {
+        const clamp2 = (value) => Math.max(0, Math.min(1, Math.fround(value)));
+        color3 = await Colormaps.getColor(kind, origin, clamp2(biome.temperature), clamp2(biome.downfall));
+      }
+      return modifier === "dark_forest" ? (color3 & 16711422) + 2634762 >> 1 : color3;
+    }
+    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
   init_dirname();
   init_buffer2();
@@ -100445,8 +100568,20 @@ property list uchar int vertex_index
   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 x4 = position?.[0], z4 = position?.[2];
+      const source = await this.biomeSource(key);
+      return source ? Biomes.getColor(biome, source, key, x4, z4) : 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;
@@ -100462,8 +100597,12 @@ property list uchar int vertex_index
         }
       }
       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 color3;
-      switch (rule.source) {
+      if (biome !== void 0) {
+        color3 = biome;
+      } else switch (rule.source) {
         case "constant":
           color3 = rule.color;
           break;
@@ -100530,6 +100669,7 @@ property list uchar int vertex_index
       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;
     }
     async init() {
       const root = AssetLoader.ROOT, scope = AssetLoader.persistentScope;
@@ -100722,11 +100862,16 @@ property list uchar int vertex_index
       const { FluidModelObject: FluidModelObject2, sampleFluid: sampleFluid2 } = await Promise.resolve().then(() => (init_FluidModelObject(), FluidModelObject_exports));
       this._fluidSampler = sample;
       const surface = sampleFluid2(kind, (x4, y5, z4) => x4 === 0 && y5 === 0 && z4 === 0 ? { fluid: kind, level: this.fluidLevel } : sample?.(x4, y5, z4) ?? {});
-      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 Matrix4().makeTranslation(...this.position.toArray());
@@ -100735,7 +100880,7 @@ property list uchar int vertex_index
       this._models = this._models.filter((model) => model !== previous);
       this._models.push(replacement);
       this._fluidModel = replacement;
-      this._fluidKey = surface.key;
+      this._fluidKey = fluidKey;
       this._isInstanced || (this._isInstanced = isInstanceReference(replacement));
       this._instanceCounter = this._isInstanced ? 1 : 0;
       if (previous) this.removeModels([previous]);
@@ -100758,6 +100903,7 @@ property list uchar int vertex_index
     }
     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;
@@ -100792,7 +100938,13 @@ property list uchar int vertex_index
       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)
       };
@@ -107376,24 +107528,48 @@ gl_FragDepth=readDepth(vUv);
       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 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 color3;
+      const resolveColor = typeof biomeColor === "function" ? () => color3 ?? (color3 = 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))) };
     }
-    /** Resolves section templates once, with a synchronous weighted choice for each cell. */
-    async prepareState(blockState3, properties = {}) {
+    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(([a4], [b4]) => a4.localeCompare(b4)));
-      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: []
         });
@@ -107405,64 +107581,67 @@ gl_FragDepth=readDepth(vUv);
       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 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((name2) => name2 === data.cullface);
-                if (local < 0) {
-                  cullFaces.push(0);
-                  continue;
-                }
-                const normal = new Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
-                const world = CUBE_FACE_OFFSETS.findIndex(([x4, y5, z4]) => Math.abs(normal.x - x4) < 1e-6 && Math.abs(normal.y - y5) < 1e-6 && Math.abs(normal.z - z4) < 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 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((name2) => name2 === data.cullface);
+            if (local < 0) {
+              cullFaces.push(0);
+              continue;
+            }
+            const normal = new Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+            const world = CUBE_FACE_OFFSETS.findIndex(([x4, y5, z4]) => Math.abs(normal.x - x4) < 1e-6 && Math.abs(normal.y - y5) < 1e-6 && Math.abs(normal.z - z4) < 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() {
@@ -107798,7 +107977,6 @@ gl_FragDepth=readDepth(vUv);
       }
       try {
         await this.clearChunkColumn(chunk.x, chunk.z);
-        let sliceStart = performance.now();
         for (const section of chunk.sections) {
           if (section.biomes) {
             const position = new Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -107812,6 +107990,9 @@ gl_FragDepth=readDepth(vUv);
             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 Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -107976,18 +108157,34 @@ gl_FragDepth=readDepth(vUv);
       const key = this.worldPosToChunkKey(pos);
       let chunk = this._chunks.get(key);
       if (typeof chunk === "undefined") {
+        const x4 = Math.floor(pos.x / 16), y5 = Math.floor(pos.y / 16), z4 = 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),
+          x4,
+          y5,
+          z4,
           (positions) => this.updateCulling(positions),
           this.sectionModels,
-          (x4, y5, z4) => {
-            const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16);
+          (x5, y6, z5) => {
+            const cx = Math.floor(x5 / 16), cy = Math.floor(y6 / 16), cz = Math.floor(z5 / 16);
             const section = this._chunks.get(`${cx}_${cy}_${cz}`);
-            const index = (y5 - cy * 16) * 256 + (z4 - cz * 16) * 16 + x4 - cx * 16;
+            const index = (y6 - cy * 16) * 256 + (z5 - cz * 16) * 16 + x5 - cx * 16;
             return (section?.fluidByteIndex(index) ?? 0) | (section?.isOccludingIndex(index) ? 64 : 0);
+          },
+          (x5, y6, z5) => this.getBiomeAt(x5, y6, z5),
+          async (biomes) => {
+            if (this._chunks.get(key) !== chunk) return;
+            const columnKey = `${x4}_${z4}`;
+            let column = this.biomes.get(columnKey);
+            if (biomes) {
+              if (!column) this.biomes.set(columnKey, column = /* @__PURE__ */ new Map());
+              column.set(y5, biomes);
+            } else {
+              column?.delete(y5);
+              if (!column?.size) this.biomes.delete(columnKey);
+            }
+            await chunk.refreshBiomes();
+            await this._chunks.get(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
           }
         );
         this._chunks.set(key, chunk);
@@ -108048,6 +108245,7 @@ gl_FragDepth=readDepth(vUv);
     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) {
@@ -108125,7 +108323,9 @@ gl_FragDepth=readDepth(vUv);
             height
           });
         }
-        fluidPages.get(fluid).fluids.push({ quads, x: x4, y: y5, z: z4, data });
+        const tintIndex = (x4 + z4 * 16 + y5 * 256) * 3;
+        const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
+        fluidPages.get(fluid).fluids.push({ quads, x: x4, y: y5, z: z4, data, tint });
       }
       pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases[a4.placements[0].atlas].animated) - Number(atlases[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
     }
@@ -108174,7 +108374,7 @@ gl_FragDepth=readDepth(vUv);
           for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
         }
       }
-      for (const { quads, x: x4, y: y5, z: z4, data } of page.fluids) {
+      for (const { quads, x: x4, y: y5, z: z4, data, tint } of page.fluids) {
         const atlas = atlases[data.atlas];
         const placement = page.placements[0];
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
@@ -108198,7 +108398,7 @@ gl_FragDepth=readDepth(vUv);
               mapU((rect[0] + rect[2]) / atlas.width),
               mapV(1 - rect[1] / atlas.height)
             ], vertex2 * 4);
-            colors.set(data.tint, vertex2 * 3);
+            colors.set(tint, vertex2 * 3);
           }
           outputIndices.set([start, start + 1, start + 2, start, start + 2, start + 3], indexOffset);
           indexOffset += 6;
@@ -108342,7 +108542,7 @@ gl_FragDepth=readDepth(vUv);
       input.cullMasks[i4] = 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;
@@ -108443,11 +108643,14 @@ gl_FragDepth=readDepth(vUv);
   init_FluidGeometry();
   init_FluidQuads();
   init_CubeFace();
+  var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
-    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell) {
+    constructor(scene, x4, y5, z4, 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();
@@ -108472,6 +108675,56 @@ gl_FragDepth=readDepth(vUv);
       const index = _Chunk.chunkPosToBlockIndex(pos);
       return this.renderedBlocks.get(index);
     }
+    getBiomeAt(posOrX, y5, z4) {
+      if (typeof posOrX === "number") return this.getBiomeAt(new Vector3(posOrX, y5, z4));
+      if (isTripleArray(posOrX)) return this.getBiomeAt(new 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 Vector3(...this.positionAt(index)));
+        if (this.onBlocksChanged) await this.onBlocksChanged(positions);
+        else await this.rebuildSectionMesh();
+      }
+    }
     async setBlockAt(posOrX, yOrBlock, z4, block) {
       if (typeof posOrX == "number") {
         return this.setBlockAt(new Vector3(posOrX, yOrBlock, z4), block);
@@ -108510,14 +108763,15 @@ gl_FragDepth=readDepth(vUv);
           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, i4) => [key, settled[i4]]));
       const positions = [];
       let failed = false, failure;
@@ -108541,7 +108795,8 @@ gl_FragDepth=readDepth(vUv);
           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;
@@ -108549,9 +108804,10 @@ gl_FragDepth=readDepth(vUv);
           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;
@@ -108561,7 +108817,9 @@ gl_FragDepth=readDepth(vUv);
               instanceMeshes: true,
               maxInstanceCount: 2e3,
               initialState: stored.properties,
-              variantPosition
+              variantPosition,
+              biome: context?.biome,
+              biomePosition: this.biomePosition(index, blockState3, stored)
             });
             object4.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
           }
@@ -108584,24 +108842,21 @@ gl_FragDepth=readDepth(vUv);
       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, i4) => [id, settled[i4]]));
       const perBlocks = [];
       let failed = false, failure;
@@ -108611,24 +108866,28 @@ gl_FragDepth=readDepth(vUv);
         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() {
@@ -108641,7 +108900,7 @@ gl_FragDepth=readDepth(vUv);
           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, {
@@ -108649,11 +108908,9 @@ gl_FragDepth=readDepth(vUv);
             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 Vector3(
             this.x * 256 + index % 16 * 16,
@@ -108672,6 +108929,68 @@ gl_FragDepth=readDepth(vUv);
       }
       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), name2 = blockState3.key?.toNamespacedString();
+      if (stored.properties?.half === "upper" && (name2 === "minecraft:tall_grass" || name2 === "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 = (color3) => perBlock || fluid?.renderModel === false ? void 0 : this.sectionModels.prepareState(blockState3, stored.properties, color3);
+      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 color3 = await Biomes.getColor(biome, "water", blockState3?.key);
+            if (color3 !== void 0 && color3 !== 4159204) context.waterTint = new Color(color3).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));
@@ -108775,7 +109094,7 @@ gl_FragDepth=readDepth(vUv);
         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 y5 = -1; y5 <= 16; y5++) {
           for (let z4 = -1; z4 <= 16; z4++) {
             for (let x4 = -1; x4 <= 16; x4++) {
@@ -108817,8 +109136,13 @@ gl_FragDepth=readDepth(vUv);
       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();