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

package/dist/bundle.js

@@ -4768,7 +4768,7 @@ var MineRender = (() => {
     }
     throw new Error(`THREE.TextureUtils: Unknown texture type ${type}.`);
   }
-  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, AgXToneMapping, NeutralToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, AlphaFormat, RGBFormat, RGBAFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, RG11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolateBezier, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, BasicDepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, LinearTransfer, SRGBTransfer, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, GLSL3, WebGLCoordinateSystem, WebGPUCoordinateSystem, _cache, _setConsoleFunction, ReversedDepthFuncs, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, _Vector2, Vector2, Quaternion, _Vector3, Vector3, _vector$c, _quaternion$5, _Matrix3, Matrix3, _m3, LINEAR_REC709_TO_XYZ, XYZ_TO_LINEAR_REC709, ColorManagement, _canvas, ImageUtils, _sourceId, TextureSource, _textureId, _tempVec3, Texture, _Vector4, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, _Matrix4, Matrix4, _v1$7, _m1$2, _zero, _one, _x, _y, _z, _matrix$2, _quaternion$4, Euler, Layers, _object3DId, _v1$6, _q1, _m1$1, _target, _position$4, _scale$3, _quaternion$3, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, _childaddedEvent, _childremovedEvent, Object3D, Group, _moveEvent, WebXRController, _colorKeywords, _hslA, _hslB, Color, _color, Scene, _v0$2, _v1$5, _v2$4, _v3$2, _vab, _vac, _vbc, _vap, _vbp, _vcp, _v40, _v41, _v42, Triangle, Box3, _points, _vector$b, _box$4, _v0$1, _v1$4, _v2$3, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _vector$a, _vector2$1, _id$2, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _box$3, _v1$3, _v2$2, Sphere, _id$1, _m1, _obj, _offset, _box$2, _boxMorphTargets, _vector$9, BufferGeometry, InterleavedBuffer, _vector$8, InterleavedBufferAttribute, _vector1, _vector2, _normalMatrix, Plane, _materialId, Material, _vector$7, _segCenter, _segDir, _diff, Ray, MeshBasicMaterial, _inverseMatrix$3, _ray$3, _sphere$6, _sphereHitAt, _vA, _vB, _vC, _tempA, _morphA, _intersectionPoint, _intersectionPointWorld, Mesh, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh$1, _sphere$4, InstancedMesh, _sphere$3, _defaultSpriteCenter, _vector$6, Frustum, LineBasicMaterial, _vStart, _vEnd, _inverseMatrix$1, _ray$1, _sphere$1, _intersectPointOnRay, _intersectPointOnSegment, Line, _start, _end, LineSegments, CompressedTexture, CubeTexture, CanvasTexture, DepthTexture, CubeDepthTexture, ExternalTexture, BoxGeometry, _v0, _v1$1, _normal, _triangle, EdgesGeometry, PlaneGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, RawShaderMaterial, MeshStandardMaterial, MeshDepthMaterial, MeshDistanceMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, BezierInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _position$2, _quaternion$2, _scale$2, Camera, _v3$1, _minTarget, _maxTarget, PerspectiveCamera, OrthographicCamera, fov, aspect, CubeCamera, ArrayCamera, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, _matrix, Raycaster, Spherical, _Matrix2, Matrix2, _vector$4, Box2, GridHelper, AxesHelper;
+  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, AgXToneMapping, NeutralToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, AlphaFormat, RGBFormat, RGBAFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, RG11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolateBezier, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, BasicDepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, LinearTransfer, SRGBTransfer, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, GLSL3, WebGLCoordinateSystem, WebGPUCoordinateSystem, _cache, _setConsoleFunction, ReversedDepthFuncs, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, _Vector2, Vector2, Quaternion, _Vector3, Vector3, _vector$c, _quaternion$5, _Matrix3, Matrix3, _m3, LINEAR_REC709_TO_XYZ, XYZ_TO_LINEAR_REC709, ColorManagement, _canvas, ImageUtils, _sourceId, TextureSource, _textureId, _tempVec3, Texture, _Vector4, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, _Matrix4, Matrix4, _v1$7, _m1$2, _zero, _one, _x, _y, _z, _matrix$2, _quaternion$4, Euler, Layers, _object3DId, _v1$6, _q1, _m1$1, _target, _position$4, _scale$3, _quaternion$3, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, _childaddedEvent, _childremovedEvent, Object3D, Group, _moveEvent, WebXRController, _colorKeywords, _hslA, _hslB, Color, _color, Scene, _v0$2, _v1$5, _v2$4, _v3$2, _vab, _vac, _vbc, _vap, _vbp, _vcp, _v40, _v41, _v42, Triangle, Box3, _points, _vector$b, _box$4, _v0$1, _v1$4, _v2$3, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _vector$a, _vector2$1, _id$2, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _box$3, _v1$3, _v2$2, Sphere, _id$1, _m1, _obj, _offset, _box$2, _boxMorphTargets, _vector$9, BufferGeometry, InterleavedBuffer, _vector$8, InterleavedBufferAttribute, _vector1, _vector2, _normalMatrix, Plane, _materialId, Material, _vector$7, _segCenter, _segDir, _diff, Ray, MeshBasicMaterial, _inverseMatrix$3, _ray$3, _sphere$6, _sphereHitAt, _vA, _vB, _vC, _tempA, _morphA, _intersectionPoint, _intersectionPointWorld, Mesh, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh$1, _sphere$4, InstancedMesh, _sphere$3, _defaultSpriteCenter, _vector$6, Frustum, LineBasicMaterial, _vStart, _vEnd, _inverseMatrix$1, _ray$1, _sphere$1, _intersectPointOnRay, _intersectPointOnSegment, Line, _start, _end, LineSegments, CompressedTexture, CubeTexture, CanvasTexture, DepthTexture, CubeDepthTexture, ExternalTexture, BoxGeometry, _v0, _v1$1, _normal, _triangle, EdgesGeometry, PlaneGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, RawShaderMaterial, MeshStandardMaterial, MeshDepthMaterial, MeshDistanceMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, BezierInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _position$2, _quaternion$2, _scale$2, Camera, _v3$1, _minTarget, _maxTarget, PerspectiveCamera, OrthographicCamera, fov, aspect, CubeCamera, ArrayCamera, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, _matrix, Raycaster, Spherical, _Matrix2, Matrix2, _vector$4, Box2, GridHelper, AxesHelper, Controls;
   var init_three_core = __esm({
     "../../node_modules/three/build/three.core.js"() {
       init_dirname();
@@ -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();
         }
@@ -21500,6 +21500,53 @@ var MineRender = (() => {
           this.material.dispose();
         }
       };
+      Controls = class extends EventDispatcher {
+        /**
+         * Constructs a new controls instance.
+         *
+         * @param {Object3D} object - The object that is managed by the controls.
+         * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+         */
+        constructor(object4, domElement = null) {
+          super();
+          this.object = object4;
+          this.domElement = domElement;
+          this.enabled = true;
+          this.state = -1;
+          this.keys = {};
+          this.mouseButtons = { LEFT: null, MIDDLE: null, RIGHT: null };
+          this.touches = { ONE: null, TWO: null };
+        }
+        /**
+         * Connects the controls to the DOM. This method has so called "side effects" since
+         * it adds the module's event listeners to the DOM.
+         *
+         * @param {HTMLElement} element - The DOM element to connect to.
+         */
+        connect(element) {
+          if (this.domElement !== null) this.disconnect();
+          this.domElement = element;
+        }
+        /**
+         * Disconnects the controls from the DOM.
+         */
+        disconnect() {
+        }
+        /**
+         * Call this method if you no longer want use to the controls. It frees all internal
+         * resources and removes all event listeners.
+         */
+        dispose() {
+        }
+        /**
+         * Controls should implement this method if they have to update their internal state
+         * per simulation step.
+         *
+         * @param {number} [delta] - The time delta in seconds.
+         */
+        update() {
+        }
+      };
       if (typeof __THREE_DEVTOOLS__ !== "undefined") {
         __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register", { detail: {
           revision: REVISION
@@ -41442,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. */
@@ -41493,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;
     }
   });
@@ -43258,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":
@@ -43414,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;
@@ -57484,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;
@@ -57573,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 = [];
@@ -95332,6 +95385,7 @@ ${shader.fragmentShader}`.replace(
     BannerPatterns: () => BannerPatterns,
     BasicAssetKey: () => BasicAssetKey,
     BatchedExecutor: () => BatchedExecutor,
+    Biomes: () => Biomes,
     BlockEntities: () => BlockEntities,
     BlockObject: () => BlockObject,
     BlockStateResolver: () => BlockStateResolver,
@@ -95365,6 +95419,7 @@ ${shader.fragmentShader}`.replace(
     EntityObject: () => EntityObject,
     Env: () => Env,
     FluidModelObject: () => FluidModelObject,
+    FlyControls: () => FlyControls,
     Fonts: () => Fonts,
     GUI_CONTAINER_LAYOUTS: () => GUI_CONTAINER_LAYOUTS,
     Geometries: () => Geometries,
@@ -95467,6 +95522,7 @@ ${shader.fragmentShader}`.replace(
     isDisposable: () => isDisposable,
     isDoubleArray: () => isDoubleArray,
     isEntityObject: () => isEntityObject,
+    isFlyControls: () => isFlyControls,
     isGuiObject: () => isGuiObject,
     isInstanceManager: () => isInstanceManager,
     isInstanceReference: () => isInstanceReference,
@@ -95792,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();
@@ -100396,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;
@@ -100413,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;
@@ -100481,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;
@@ -100673,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());
@@ -100686,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]);
@@ -100709,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;
@@ -100743,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)
       };
@@ -101366,6 +101567,324 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
+  // src/renderer/FlyControls.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  var VANILLA_FLY_SPEED = 10.89;
+  var PITCH_LIMIT = Math.PI / 2;
+  var MOVE_EPSILON = 1e-6;
+  var _euler = new Euler(0, 0, 0, "YXZ");
+  var _forward = new Vector3();
+  var _right = new Vector3();
+  var _targetVelocity = new Vector3();
+  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 Vector3();
+      this._lastPosition = new Vector3();
+      this._lastQuaternion = new Quaternion();
+      this._position0 = new Vector3();
+      this._quaternion0 = new Quaternion();
+      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(MathUtils.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(MathUtils.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 = MathUtils.clamp(forward + (joystick.originY - joystick.y) / radius, -1, 1);
+        strafe = MathUtils.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 - MathUtils.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(code2) {
+      for (const action in this.keys) {
+        if (this.keys[action].includes(code2)) 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, max2] = this.speedRange;
+      this.movementSpeed = MathUtils.clamp(this.movementSpeed * Math.pow(1.15, -steps), Math.min(min, max2), Math.max(min, max2));
+    }
+    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 = MathUtils.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_dirname();
   init_buffer2();
@@ -105204,20 +105723,77 @@ gl_FragDepth=readDepth(vUv);
     }
     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 Vector3(target[0], target[1], target[2]);
+      return new Vector3();
+    }
+    createControlsFor(mode2, target) {
+      let controls;
+      if (mode2 === "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(mode2) {
+      const current = this._controls;
+      if (this._disposed || !current) return void 0;
+      if (this.controlsMode === mode2) return current;
+      let target;
+      if (isFlyControls(current)) {
+        const distance = this._orbitDistance ?? (this.camera.position.distanceTo(this.initialTarget()) || 1);
+        target = new Vector3(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(mode2, 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;
@@ -105294,6 +105870,12 @@ gl_FragDepth=readDepth(vUv);
       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;
@@ -105370,6 +105952,7 @@ gl_FragDepth=readDepth(vUv);
         this.renderer.setAnimationLoop(null);
       }
       this._nextFrameTime = void 0;
+      this._controlsTime = void 0;
       for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
     }
     /**
@@ -105399,10 +105982,7 @@ gl_FragDepth=readDepth(vUv);
       }
       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) {
@@ -105419,9 +105999,7 @@ gl_FragDepth=readDepth(vUv);
     }
     animate(t5 = performance.now()) {
       if (!this._running) return;
-      if (this._controls?.enabled) {
-        this._controls.update();
-      }
+      this.updateControls(t5);
       if (!this._running) return;
       if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size && !this._videoExporter) return;
       const interval = this._frameInterval;
@@ -105458,7 +106036,7 @@ gl_FragDepth=readDepth(vUv);
     /** 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();
     }
     /**
@@ -105488,7 +106066,7 @@ gl_FragDepth=readDepth(vUv);
         try {
           if (!wasRunning) this.start();
           this._videoExporter = exporter;
-          if (this._controls?.enabled) this._controls.update();
+          this.updateControls();
           this.drawFrame();
         } catch (error2) {
           exporter.cancel(error2);
@@ -105539,6 +106117,19 @@ gl_FragDepth=readDepth(vUv);
     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)({}, {
@@ -105572,7 +106163,8 @@ gl_FragDepth=readDepth(vUv);
       enabled: true
     },
     controls: {
-      enabled: false
+      enabled: false,
+      mode: "orbit"
     },
     debug: {
       grid: false,
@@ -106936,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 once, with a synchronous weighted choice for each cell. */
-    async prepareState(blockState3, properties = {}) {
+    /** Resolves section templates for one tint palette, with a synchronous weighted choice for each cell. */
+    async prepareState(blockState3, properties = {}, biomeColor) {
+      const prepared = await this.state(blockState3, properties);
+      if (!prepared) return void 0;
+      let 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))) };
+    }
+    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: []
         });
@@ -106965,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() {
@@ -107358,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);
@@ -107372,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);
@@ -107536,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);
@@ -107608,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) {
@@ -107685,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));
     }
@@ -107734,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;
@@ -107758,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;
@@ -107902,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;
@@ -108003,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();
@@ -108032,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);
@@ -108070,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;
@@ -108101,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;
@@ -108109,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;
@@ -108121,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));
           }
@@ -108144,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;
@@ -108171,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() {
@@ -108201,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, {
@@ -108209,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,
@@ -108232,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));
@@ -108335,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++) {
@@ -108377,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();