minerender 2.1.0-alpha.114 → 2.1.0-alpha.116

package/dist/browser/index.mjs

@@ -279,7 +279,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. */
@@ -330,6 +331,7 @@ var init_Caching = __esm({
     _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;
   }
 });
@@ -1676,7 +1678,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":
@@ -1820,15 +1822,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;
@@ -7699,6 +7705,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 ?? (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
 init_AssetKey();
 init_AssetLoader();
@@ -12178,8 +12294,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;
@@ -12195,8 +12323,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;
@@ -12255,6 +12387,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;
   }
   async init() {
     const root = AssetLoader.ROOT, scope = AssetLoader.persistentScope;
@@ -12447,11 +12580,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 Matrix411().makeTranslation(...this.position.toArray());
@@ -12460,7 +12598,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 || (this._isInstanced = isInstanceReference(replacement));
     this._instanceCounter = this._isInstanced ? 1 : 0;
     if (previous) this.removeModels([previous]);
@@ -12483,6 +12621,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;
@@ -12517,7 +12656,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)
     };
@@ -13104,6 +13249,321 @@ init_ModelObject();
 // src/index.ts
 init_nbt();
 
+// src/renderer/FlyControls.ts
+import { Controls, Euler as Euler11, MathUtils as MathUtils2, Quaternion as Quaternion6, Vector3 as Vector313 } from "three";
+var VANILLA_FLY_SPEED = 10.89;
+var PITCH_LIMIT = Math.PI / 2;
+var MOVE_EPSILON = 1e-6;
+var _euler = new Euler11(0, 0, 0, "YXZ");
+var _forward = new Vector313();
+var _right = new Vector313();
+var _targetVelocity = new Vector313();
+var FlyControls = class extends Controls {
+  constructor(camera, domElement) {
+    super(camera, domElement ?? null);
+    this.isFlyControls = true;
+    /** Horizontal and vertical speed in scene units per second; vanilla creative flight by default. */
+    this.movementSpeed = 16 * VANILLA_FLY_SPEED;
+    /** Speed multiplier while the sprint key is held. */
+    this.sprintMultiplier = 2;
+    /** Radians per pixel of pointer movement. */
+    this.lookSpeed = 2e-3;
+    /** Smooth acceleration and deceleration, approximating vanilla flight momentum. */
+    this.enableDamping = true;
+    /** Portion of the remaining velocity change applied per 60 Hz frame (0–1) when damping is enabled. */
+    this.dampingFactor = 0.25;
+    /** Capture the pointer on click so the mouse turns the camera without dragging; dragging works regardless. */
+    this.pointerLock = true;
+    /** Scroll the wheel to change `movementSpeed` within `speedRange`. */
+    this.enableWheelSpeed = true;
+    /** Minimum and maximum `movementSpeed` reachable with the wheel. */
+    this.speedRange = [16, 16 * 500];
+    /** Touch joystick travel in CSS pixels for full speed. */
+    this.joystickRadius = 64;
+    /** Key bindings by `KeyboardEvent.code`. */
+    this.keys = {
+      forward: ["KeyW", "ArrowUp"],
+      back: ["KeyS", "ArrowDown"],
+      left: ["KeyA", "ArrowLeft"],
+      right: ["KeyD", "ArrowRight"],
+      up: ["Space"],
+      down: ["ShiftLeft", "ShiftRight"],
+      sprint: ["ControlLeft", "ControlRight"]
+    };
+    this._pressed = /* @__PURE__ */ new Set();
+    this._velocity = new Vector313();
+    this._lastPosition = new Vector313();
+    this._lastQuaternion = new Quaternion6();
+    this._position0 = new Vector313();
+    this._quaternion0 = new Quaternion6();
+    this._dragMoved = false;
+    this._locked = false;
+    this._onKeyDown = (event) => this.handleKey(event, true);
+    this._onKeyUp = (event) => this.handleKey(event, false);
+    this._onPointerDown = (event) => this.handlePointerDown(event);
+    this._onPointerMove = (event) => this.handlePointerMove(event);
+    this._onPointerUp = (event) => this.handlePointerUp(event);
+    this._onPointerLockChange = () => this.handlePointerLockChange();
+    this._onContextMenu = (event) => event.preventDefault();
+    this._onWheel = (event) => this.handleWheel(event);
+    this._onBlur = () => this.releaseKeys();
+    this._lastPosition.copy(camera.position);
+    this._lastQuaternion.copy(camera.quaternion);
+    this.saveState();
+    if (domElement) this.connect(domElement);
+  }
+  connect(element) {
+    super.connect(element);
+    const document2 = element.ownerDocument;
+    document2.addEventListener("keydown", this._onKeyDown);
+    document2.addEventListener("keyup", this._onKeyUp);
+    document2.addEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.addEventListener("blur", this._onBlur);
+    element.addEventListener("pointerdown", this._onPointerDown);
+    element.addEventListener("pointermove", this._onPointerMove);
+    element.addEventListener("pointerup", this._onPointerUp);
+    element.addEventListener("pointercancel", this._onPointerUp);
+    element.addEventListener("contextmenu", this._onContextMenu);
+    element.addEventListener("wheel", this._onWheel, { passive: false });
+    element.addEventListener("blur", this._onBlur);
+    element.style.touchAction = "none";
+    if (element.tabIndex < 0) element.tabIndex = 0;
+  }
+  disconnect() {
+    const element = this.domElement;
+    if (!element) return;
+    const document2 = element.ownerDocument;
+    document2.removeEventListener("keydown", this._onKeyDown);
+    document2.removeEventListener("keyup", this._onKeyUp);
+    document2.removeEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.removeEventListener("blur", this._onBlur);
+    element.removeEventListener("pointerdown", this._onPointerDown);
+    element.removeEventListener("pointermove", this._onPointerMove);
+    element.removeEventListener("pointerup", this._onPointerUp);
+    element.removeEventListener("pointercancel", this._onPointerUp);
+    element.removeEventListener("contextmenu", this._onContextMenu);
+    element.removeEventListener("wheel", this._onWheel);
+    element.removeEventListener("blur", this._onBlur);
+    element.style.touchAction = "auto";
+    this.unlock();
+    this._locked = false;
+    this.releaseKeys();
+    this._dragPointer = void 0;
+    this._joystick = void 0;
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /** Whether mouse look currently owns the pointer. */
+  get locked() {
+    return this._locked;
+  }
+  /** Requests pointer capture; browsers only allow this from a user gesture. */
+  lock() {
+    const element = this.domElement;
+    if (!element || this._locked || typeof element.requestPointerLock !== "function") return;
+    try {
+      const result = element.requestPointerLock();
+      if (result instanceof Promise) result.catch(() => void 0);
+    } catch {
+    }
+  }
+  /** Releases a captured pointer. */
+  unlock() {
+    const document2 = this.domElement?.ownerDocument;
+    if (document2?.pointerLockElement && document2.pointerLockElement === this.domElement) {
+      document2.exitPointerLock();
+    }
+  }
+  /** Stores the camera pose that {@link reset} restores. */
+  saveState() {
+    this._position0.copy(this.object.position);
+    this._quaternion0.copy(this.object.quaternion);
+  }
+  /** Restores the saved camera pose and stops movement. */
+  reset() {
+    this.object.position.copy(this._position0);
+    this.object.quaternion.copy(this._quaternion0);
+    this._velocity.set(0, 0, 0);
+    this.notifyChange();
+  }
+  /** Horizontal yaw in radians, where zero looks toward -Z. */
+  get yaw() {
+    return _euler.setFromQuaternion(this.object.quaternion).y;
+  }
+  /** Vertical pitch in radians, positive looking up. */
+  get pitch() {
+    return _euler.setFromQuaternion(this.object.quaternion).x;
+  }
+  /** Turns the camera; pitch is clamped to straight up and down. */
+  setRotation(yaw, pitch) {
+    _euler.set(MathUtils2.clamp(pitch, -PITCH_LIMIT, PITCH_LIMIT), yaw, 0);
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+  /** Points the camera at a position without rolling it. */
+  lookAt(target) {
+    _forward.copy(target).sub(this.object.position);
+    if (_forward.lengthSq() < MOVE_EPSILON) return;
+    _forward.normalize();
+    this.setRotation(Math.atan2(-_forward.x, -_forward.z), Math.asin(MathUtils2.clamp(_forward.y, -1, 1)));
+  }
+  /** Whether an action's key is held. */
+  isPressed(action) {
+    return this._pressed.has(action);
+  }
+  /**
+   * Advances movement by `delta` seconds (measured since the previous call when omitted)
+   * and dispatches `change` when the camera moved.
+   */
+  update(delta) {
+    if (delta === void 0) {
+      const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+      delta = this._lastTime === void 0 ? 0 : (now - this._lastTime) / 1e3;
+      this._lastTime = now;
+    }
+    if (!this.enabled) {
+      this._velocity.set(0, 0, 0);
+      return;
+    }
+    if (delta > 0) this.move(delta);
+    this.notifyChange();
+  }
+  move(delta) {
+    const camera = this.object;
+    let forward = (this._pressed.has("forward") ? 1 : 0) - (this._pressed.has("back") ? 1 : 0);
+    let strafe = (this._pressed.has("right") ? 1 : 0) - (this._pressed.has("left") ? 1 : 0);
+    const climb = (this._pressed.has("up") ? 1 : 0) - (this._pressed.has("down") ? 1 : 0);
+    const joystick = this._joystick;
+    if (joystick) {
+      const radius = Math.max(this.joystickRadius, 1);
+      forward = MathUtils2.clamp(forward + (joystick.originY - joystick.y) / radius, -1, 1);
+      strafe = MathUtils2.clamp(strafe + (joystick.x - joystick.originX) / radius, -1, 1);
+    }
+    _euler.setFromQuaternion(camera.quaternion);
+    const yaw = _euler.y;
+    _forward.set(-Math.sin(yaw), 0, -Math.cos(yaw));
+    _right.set(Math.cos(yaw), 0, -Math.sin(yaw));
+    _targetVelocity.set(0, 0, 0);
+    if (forward || strafe || climb) {
+      _targetVelocity.addScaledVector(_forward, forward).addScaledVector(_right, strafe);
+      if (_targetVelocity.lengthSq() > 1) _targetVelocity.normalize();
+      _targetVelocity.y = climb;
+      const speed = this.movementSpeed * (this._pressed.has("sprint") ? this.sprintMultiplier : 1);
+      _targetVelocity.multiplyScalar(speed);
+    }
+    if (this.enableDamping) {
+      const blend = 1 - Math.pow(1 - MathUtils2.clamp(this.dampingFactor, 0, 1), delta * 60);
+      this._velocity.lerp(_targetVelocity, blend);
+      if (_targetVelocity.lengthSq() === 0 && this._velocity.lengthSq() < MOVE_EPSILON) this._velocity.set(0, 0, 0);
+    } else {
+      this._velocity.copy(_targetVelocity);
+    }
+    camera.position.addScaledVector(this._velocity, delta);
+  }
+  notifyChange() {
+    const camera = this.object;
+    if (this._lastPosition.distanceToSquared(camera.position) > MOVE_EPSILON || 8 * (1 - this._lastQuaternion.dot(camera.quaternion)) > MOVE_EPSILON) {
+      this._lastPosition.copy(camera.position);
+      this._lastQuaternion.copy(camera.quaternion);
+      this.dispatchEvent({ type: "change" });
+    }
+  }
+  releaseKeys() {
+    this._pressed.clear();
+  }
+  handleKey(event, down) {
+    const action = this.actionFor(event.code);
+    if (!action) return;
+    const ownsInput = this.enabled && (this._locked || event.target === this.domElement);
+    if (down && !ownsInput) return;
+    const pressed = this._pressed.has(action);
+    if (down) this._pressed.add(action);
+    else this._pressed.delete(action);
+    if (ownsInput || this.enabled && pressed) event.preventDefault();
+  }
+  actionFor(code) {
+    for (const action in this.keys) {
+      if (this.keys[action].includes(code)) return action;
+    }
+    return void 0;
+  }
+  handlePointerDown(event) {
+    const element = this.domElement;
+    if (!this.enabled || !element) return;
+    element.focus?.({ preventScroll: true });
+    if (this._locked) return;
+    if (event.pointerType === "touch" && !this._joystick && this.onJoystickSide(event)) {
+      this._joystick = { id: event.pointerId, originX: event.clientX, originY: event.clientY, x: event.clientX, y: event.clientY };
+      element.setPointerCapture?.(event.pointerId);
+      return;
+    }
+    if (this._dragPointer !== void 0) return;
+    if (event.pointerType === "mouse" && event.button !== 0 && event.button !== 2) return;
+    this._dragPointer = event.pointerId;
+    this._dragMoved = false;
+    element.setPointerCapture?.(event.pointerId);
+  }
+  onJoystickSide(event) {
+    const rect = this.domElement?.getBoundingClientRect?.();
+    return !!rect && event.clientX < rect.left + rect.width / 2;
+  }
+  handlePointerMove(event) {
+    if (!this.enabled) return;
+    const joystick = this._joystick;
+    if (joystick && event.pointerId === joystick.id) {
+      joystick.x = event.clientX;
+      joystick.y = event.clientY;
+      return;
+    }
+    if (!this._locked && event.pointerId !== this._dragPointer) return;
+    const dx = event.movementX ?? 0;
+    const dy = event.movementY ?? 0;
+    if (!dx && !dy) return;
+    this._dragMoved = true;
+    this.turn(dx, dy);
+  }
+  handlePointerUp(event) {
+    if (this._joystick?.id === event.pointerId) {
+      this._joystick = void 0;
+      this.domElement?.releasePointerCapture?.(event.pointerId);
+      return;
+    }
+    if (event.pointerId !== this._dragPointer) return;
+    this._dragPointer = void 0;
+    this.domElement?.releasePointerCapture?.(event.pointerId);
+    if (this.enabled && this.pointerLock && !this._dragMoved && event.pointerType === "mouse" && event.button === 0) {
+      this.lock();
+    }
+  }
+  handleWheel(event) {
+    if (!this.enabled || !this.enableWheelSpeed) return;
+    event.preventDefault();
+    const steps = event.deltaMode === 0 ? event.deltaY / 100 : event.deltaY;
+    const [min, max] = this.speedRange;
+    this.movementSpeed = MathUtils2.clamp(this.movementSpeed * Math.pow(1.15, -steps), Math.min(min, max), Math.max(min, max));
+  }
+  handlePointerLockChange() {
+    const document2 = this.domElement?.ownerDocument;
+    const locked = !!document2 && document2.pointerLockElement === this.domElement;
+    if (locked === this._locked) return;
+    this._locked = locked;
+    if (!locked) this.releaseKeys();
+    this.dispatchEvent({ type: locked ? "lock" : "unlock" });
+  }
+  turn(dx, dy) {
+    _euler.setFromQuaternion(this.object.quaternion);
+    _euler.y -= dx * this.lookSpeed;
+    _euler.x = MathUtils2.clamp(_euler.x - dy * this.lookSpeed, -PITCH_LIMIT, PITCH_LIMIT);
+    _euler.z = 0;
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+};
+function isFlyControls(obj) {
+  return obj?.isFlyControls === true;
+}
+
 // src/renderer/MineRenderScene.ts
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
@@ -14170,7 +14630,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace7, Vector3 as Vector314, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace7, Vector3 as Vector315, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
 init_Model();
@@ -14182,11 +14642,11 @@ import { EffectComposer, RenderPass } from "postprocessing";
 import {
   EventDispatcher,
   MOUSE,
-  Quaternion as Quaternion6,
+  Quaternion as Quaternion7,
   Spherical,
   TOUCH,
   Vector2 as Vector26,
-  Vector3 as Vector313
+  Vector3 as Vector314
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -14200,7 +14660,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector313();
+    this.target = new Vector314();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -14252,11 +14712,11 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector313();
-      const quat = new Quaternion6().setFromUnitVectors(object4.up, new Vector313(0, 1, 0));
+      const offset = new Vector314();
+      const quat = new Quaternion7().setFromUnitVectors(object4.up, new Vector314(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector313();
-      const lastQuaternion = new Quaternion6();
+      const lastPosition = new Vector314();
+      const lastQuaternion = new Quaternion7();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -14345,7 +14805,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector313();
+    const panOffset = new Vector314();
     let zoomChanged = false;
     const rotateStart = new Vector26();
     const rotateEnd = new Vector26();
@@ -14371,7 +14831,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector313();
+      const v = new Vector314();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -14379,7 +14839,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector313();
+      const v = new Vector314();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -14392,7 +14852,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector313();
+      const offset = new Vector314();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -14947,20 +15407,77 @@ var _Renderer = class _Renderer {
   }
   createControls() {
     if (!this.options.controls?.enabled) return void 0;
-    const position = this.camera.position.clone();
-    const controls = new OrbitControls(this.camera, this.renderer.domElement);
-    this.camera.position.copy(position);
+    return this.createControlsFor(this.options.controls.mode ?? "orbit", this.initialTarget());
+  }
+  initialTarget() {
     const target = this.options.camera.lookingAt;
-    if (isVector3(target)) {
+    if (isVector3(target)) return target.clone();
+    if (isTripleArray(target)) return new Vector315(target[0], target[1], target[2]);
+    return new Vector315();
+  }
+  createControlsFor(mode, target) {
+    let controls;
+    if (mode === "fly") {
+      controls = new FlyControls(this.camera, this.renderer.domElement);
+      controls.lookAt(target);
+      controls.saveState();
+    } else {
+      const position = this.camera.position.clone();
+      controls = new OrbitControls(this.camera, this.renderer.domElement);
+      this.camera.position.copy(position);
       controls.target.copy(target);
-    } else if (isTripleArray(target)) {
-      controls.target.set(target[0], target[1], target[2]);
+      controls.update();
+      controls.saveState();
     }
-    controls.update();
-    controls.saveState();
+    this._controlsTime = void 0;
     this.registerEventDispatcher(controls);
     return controls;
   }
+  /**
+   * Replaces renderer-owned controls with the selected mode, keeping the camera where it is.
+   * Switching to orbit controls targets the point the camera looks at, at the previous orbit distance.
+   * Returns the new controls, or undefined when controls were disabled at construction or after disposal.
+   */
+  setControlsMode(mode) {
+    const current = this._controls;
+    if (this._disposed || !current) return void 0;
+    if (this.controlsMode === mode) return current;
+    let target;
+    if (isFlyControls(current)) {
+      const distance = this._orbitDistance ?? (this.camera.position.distanceTo(this.initialTarget()) || 1);
+      target = new Vector315(0, 0, -distance).applyQuaternion(this.camera.quaternion).add(this.camera.position);
+    } else {
+      target = current.target.clone();
+      this._orbitDistance = this.camera.position.distanceTo(target);
+    }
+    const enabled = current.enabled;
+    this.disposeControls(current);
+    this._controls = this.createControlsFor(mode, target);
+    this._controls.enabled = enabled;
+    this.dirty = true;
+    return this._controls;
+  }
+  disposeControls(controls) {
+    this._controls = void 0;
+    this.unregisterEventDispatcher(controls);
+    controls.enabled = false;
+    controls.dispose();
+  }
+  /** Advances owned controls; without a frame time, flight movement does not progress. */
+  updateControls(time) {
+    const controls = this._controls;
+    if (!controls?.enabled) {
+      this._controlsTime = void 0;
+      return;
+    }
+    if (!isFlyControls(controls)) {
+      controls.update();
+      return;
+    }
+    const previous = this._controlsTime;
+    if (time !== void 0) this._controlsTime = time;
+    controls.update(time === void 0 || previous === void 0 ? 0 : (time - previous) / 1e3);
+  }
   //</editor-fold>
   init() {
     if (this._disposed) return;
@@ -15037,6 +15554,12 @@ var _Renderer = class _Renderer {
     events.add(changeEvent2);
     dispatcher.addEventListener(changeEvent2, this._changeListener);
   }
+  unregisterEventDispatcher(dispatcher) {
+    const events = this._eventDispatchers.get(dispatcher);
+    if (!events) return;
+    for (const event of events) dispatcher.removeEventListener(event, this._changeListener);
+    this._eventDispatchers.delete(dispatcher);
+  }
   /** Updates the camera and canvas size. Width and height are in CSS pixels. */
   resize(width, height) {
     if (this._disposed) return;
@@ -15113,6 +15636,7 @@ var _Renderer = class _Renderer {
       this.renderer.setAnimationLoop(null);
     }
     this._nextFrameTime = void 0;
+    this._controlsTime = void 0;
     for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
   }
   /**
@@ -15142,10 +15666,7 @@ var _Renderer = class _Renderer {
     }
     this._element = void 0;
     if (this._controls) {
-      const controls = this._controls;
-      this._controls = void 0;
-      controls.enabled = false;
-      controls.dispose();
+      this.disposeControls(this._controls);
     }
     this.scene.clear();
     for (const helper of this._debugHelpers) {
@@ -15162,9 +15683,7 @@ var _Renderer = class _Renderer {
   }
   animate(t = performance.now()) {
     if (!this._running) return;
-    if (this._controls?.enabled) {
-      this._controls.update();
-    }
+    this.updateControls(t);
     if (!this._running) return;
     if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size && !this._videoExporter) return;
     const interval = this._frameInterval;
@@ -15201,7 +15720,7 @@ var _Renderer = class _Renderer {
   /** Draws a fresh frame without starting the animation loop or invoking frame callbacks. */
   renderOnce() {
     if (this._disposed) throw new Error("Cannot render a disposed renderer");
-    if (this._controls?.enabled) this._controls.update();
+    this.updateControls();
     this.drawFrame();
   }
   /**
@@ -15231,7 +15750,7 @@ var _Renderer = class _Renderer {
       try {
         if (!wasRunning) this.start();
         this._videoExporter = exporter;
-        if (this._controls?.enabled) this._controls.update();
+        this.updateControls();
         this.drawFrame();
       } catch (error) {
         exporter.cancel(error);
@@ -15282,6 +15801,19 @@ var _Renderer = class _Renderer {
   get controls() {
     return this._controls;
   }
+  /** Renderer-owned OrbitControls, or undefined in fly mode or without controls. */
+  get orbitControls() {
+    return this._controls && !isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** Renderer-owned {@link FlyControls}, or undefined in orbit mode or without controls. */
+  get flyControls() {
+    return isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** The active renderer-owned controls mode, or undefined without controls. */
+  get controlsMode() {
+    if (!this._controls) return void 0;
+    return isFlyControls(this._controls) ? "fly" : "orbit";
+  }
   ///
 };
 _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
@@ -15299,8 +15831,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new Vector314(50, 50, 50),
-    lookingAt: new Vector314(0, 0, 0)
+    position: new Vector315(50, 50, 50),
+    lookingAt: new Vector315(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -15315,7 +15847,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
     enabled: true
   },
   controls: {
-    enabled: false
+    enabled: false,
+    mode: "orbit"
   },
   debug: {
     grid: false,
@@ -16548,14 +17081,14 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector317 } from "three";
+import { Color as Color13, Vector3 as Vector318 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
 init_util();
-import { Vector3 as Vector316 } from "three";
+import { Vector3 as Vector317 } from "three";
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
@@ -16564,7 +17097,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { BufferAttribute as BufferAttribute7, BufferGeometry as BufferGeometry8, Matrix4 as Matrix412, Vector3 as Vector315 } from "three";
+import { BufferAttribute as BufferAttribute7, BufferGeometry as BufferGeometry8, Matrix4 as Matrix412, Vector3 as Vector316 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -16618,24 +17151,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 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 ?? (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))) };
   }
-  /** 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(([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: []
       });
@@ -16647,64 +17204,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 Matrix412().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 Vector315(...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 Matrix412().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 Vector316(...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() {
@@ -16881,17 +17441,17 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector316(posOrX, y, z));
+      return this.getBlockAt(new Vector317(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new Vector316(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector316(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector317(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector317(...posOrX));
     this.validatePosBounds(posOrX);
     const cx = Math.floor(posOrX.x / 16), cy = Math.floor(posOrX.y / 16), cz = Math.floor(posOrX.z / 16);
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
@@ -16899,10 +17459,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -16913,10 +17473,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new Vector316(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new Vector317(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new Vector316(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new Vector317(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -16942,7 +17502,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new Vector316(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector317(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -16958,7 +17518,7 @@ var MineRenderWorld = class {
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new Vector316();
+      const position = new Vector317();
       for (const block of multiblock.blocks) {
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
@@ -16998,7 +17558,7 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ?? (positions = blocks.map(({ index }) => new Vector316(
+        positions ?? (positions = blocks.map(({ index }) => new Vector317(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
@@ -17034,10 +17594,9 @@ 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 Vector316(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const copy = [...section.biomes];
           if (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0)) {
@@ -17048,9 +17607,12 @@ 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 Vector316(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -17144,7 +17706,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
-    const neighbor = new Vector316();
+    const neighbor = new Vector317();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
       const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
@@ -17212,18 +17774,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);
@@ -17236,7 +17814,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -17244,7 +17822,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -17278,6 +17856,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) {
@@ -17355,7 +17934,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));
   }
@@ -17404,7 +17985,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;
@@ -17428,7 +18009,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;
@@ -17569,7 +18150,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;
@@ -17670,17 +18251,20 @@ var SectionMesh = class _SectionMesh extends Group3 {
 init_FluidGeometry();
 init_FluidQuads();
 init_CubeFace();
+var WATER_TINT2 = new Color13(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();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new Vector317();
+    this.blockPosition = new Vector318();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.scene = scene;
@@ -17690,21 +18274,71 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector317(posOrX, y, z));
+      return this.getBlockAt(new Vector318(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
     return this.renderedBlocks.get(index);
   }
+  getBiomeAt(posOrX, y, z) {
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector318(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector318(...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 Vector318(...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 Vector317(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector318(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -17737,14 +18371,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;
@@ -17757,7 +18392,7 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
-      const worldPos = new Vector317(
+      const worldPos = new Vector318(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -17768,7 +18403,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;
@@ -17776,9 +18412,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;
@@ -17788,7 +18425,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));
         }
@@ -17811,24 +18450,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;
@@ -17838,24 +18474,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() {
@@ -17868,7 +18508,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, {
@@ -17876,13 +18516,11 @@ 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 Vector317(
+        object4.setPosition(new Vector318(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
@@ -17899,6 +18537,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 Color13(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));
@@ -18002,7 +18702,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++) {
@@ -18033,7 +18733,7 @@ var Chunk = class _Chunk {
   /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
   async clear(notify = true) {
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector317(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector318(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -18044,8 +18744,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();
@@ -18061,14 +18766,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector317(
+    return new Vector318(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector317(
+    return new Vector318(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -18266,6 +18971,7 @@ export {
   BannerPatterns,
   BasicAssetKey,
   BatchedExecutor,
+  Biomes,
   BlockEntities,
   BlockObject,
   BlockStateResolver,
@@ -18299,6 +19005,7 @@ export {
   EntityObject,
   Env,
   FluidModelObject,
+  FlyControls,
   Fonts,
   GUI_CONTAINER_LAYOUTS,
   Geometries,
@@ -18401,6 +19108,7 @@ export {
   isDisposable,
   isDoubleArray,
   isEntityObject,
+  isFlyControls,
   isGuiObject,
   isInstanceManager,
   isInstanceReference,