minerender 2.1.0-alpha.60 → 2.1.0-alpha.62

package/dist/browser/index.js

@@ -1452,7 +1452,7 @@ var init_Models = __esm({
       }
       static async getItemModel(key) {
         const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-        const model = await this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(itemKey.serialize()), async () => {
+        const model = await this.PERSISTENT_CACHE.getOrLoad(`item-v2:${AssetLoader.persistentKey(itemKey.serialize())}`, async () => {
           const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
           if (!result) return void 0;
           if (result.key.assetType !== "items") return { ...result.asset, key };
@@ -1461,7 +1461,7 @@ var init_Models = __esm({
           modelKey.root = key.root;
           const model2 = await this.getRaw(modelKey);
           if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
-          return selected.special ? { ...model2, special: selected.special } : model2;
+          return { ...model2, ...selected.special && { special: selected.special }, ...selected.tints && { tints: selected.tints } };
         });
         return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
       }
@@ -1472,7 +1472,7 @@ var init_Models = __esm({
         }
         switch (node.type.replace(/^minecraft:/, "")) {
           case "model":
-            if (typeof node.model === "string" && node.model) return { model: node.model };
+            if (typeof node.model === "string" && node.model) return { model: node.model, tints: node.tints };
             break;
           case "special": {
             if (!node.base || !node.model || typeof node.model !== "object") break;
@@ -3238,11 +3238,11 @@ var init_Entities = __esm({
         return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
       }
       /**
-       * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
+       * Native and sampled vanilla clips by name, or undefined when the model or selected version has none.
        */
       static async getAnimations(modelKey) {
         const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
         const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
         return file?.animations;
       }
@@ -3292,7 +3292,7 @@ function sampleEntityKeyframes(keyframes, time) {
   let low = 0, high = keyframes.length;
   while (low < high) {
     const middle = low + high >>> 1;
-    if (time <= keyframes[middle].time) high = middle;
+    if (time < keyframes[middle].time) high = middle;
     else low = middle + 1;
   }
   const a = Math.max(0, low - 1);
@@ -3331,9 +3331,10 @@ var init_EntityAnimation = __esm({
 });
 
 // src/entity/scene/EntityAnimationPlayer.ts
-var ZERO, EntityAnimationPlayer;
+var import_three11, ZERO, EntityAnimationPlayer;
 var init_EntityAnimationPlayer = __esm({
   "src/entity/scene/EntityAnimationPlayer.ts"() {
+    import_three11 = require("three");
     init_EntityAnimation();
     ZERO = [0, 0, 0];
     EntityAnimationPlayer = class {
@@ -3350,25 +3351,45 @@ var init_EntityAnimationPlayer = __esm({
         return this._time;
       }
       /**
-       * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
-       * bones without a matching part are skipped.
+       * Starts an animation on matching named parts. Supplied baked poses are the baseline for offsets;
+       * without them, the current pose is used. Stopping restores the pose from before playback.
        */
-      play(layers, animation, options = {}) {
+      play(layers, animation, options = {}, poses) {
         this.stop();
         this._animation = animation;
         this._time = options.time ?? 0;
         this.loop = options.loop ?? animation.loop;
         this.speed = options.speed ?? 1;
         for (const layer of layers) {
-          for (const bone of Object.keys(animation.bones)) {
-            const object = layer.getObjectByName(`group:${bone}`);
-            if (!object) continue;
-            this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
+          const objects = [];
+          if (poses) {
+            layer.traverse((object) => {
+              if (poses.has(object)) objects.push(object);
+            });
+          } else {
+            for (const bone of Object.keys(animation.bones)) {
+              const object = layer.getObjectByName(`group:${bone}`);
+              if (object) objects.push(object);
+            }
+          }
+          for (const object of objects) {
+            const bone = object.name.slice("group:".length);
+            const pose = poses?.get(object);
+            this.parts.push({
+              bone,
+              object,
+              position: object.position.clone(),
+              rotation: object.rotation.clone(),
+              scale: object.scale.clone(),
+              basePosition: pose ? new import_three11.Vector3(...pose.offset) : object.position.clone(),
+              baseRotation: pose ? new import_three11.Euler(...pose.rotation, "ZYX") : object.rotation.clone(),
+              baseScale: pose ? new import_three11.Vector3(...pose.scale ?? [1, 1, 1]) : object.scale.clone()
+            });
           }
         }
         this.apply();
       }
-      /** Restores the default poses. Returns whether an animation was active. */
+      /** Restores the poses from before playback. Returns whether an animation was active. */
       stop() {
         if (!this._animation) return false;
         for (const part of this.parts) {
@@ -3397,10 +3418,10 @@ var init_EntityAnimationPlayer = __esm({
       apply() {
         const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
         for (const part of this.parts) {
-          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
-          part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
-          part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
-          part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
+          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone] ?? {};
+          part.object.position.set(part.basePosition.x + position[0], part.basePosition.y + position[1], part.basePosition.z + position[2]);
+          part.object.rotation.set(part.baseRotation.x + rotation[0], part.baseRotation.y + rotation[1], part.baseRotation.z + rotation[2], part.baseRotation.order);
+          part.object.scale.set(part.baseScale.x + scale[0], part.baseScale.y + scale[1], part.baseScale.z + scale[2]);
         }
       }
     };
@@ -3470,10 +3491,10 @@ var init_InstanceReference = __esm({
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
-var import_three11, import_ts_deepmerge3, p6, _SceneObject, SceneObject;
+var import_three12, import_ts_deepmerge3, p6, _SceneObject, SceneObject;
 var init_SceneObject = __esm({
   "src/renderer/SceneObject.ts"() {
-    import_three11 = require("three");
+    import_three12 = require("three");
     init_Geometries();
     init_UVMapper();
     init_Axis();
@@ -3485,7 +3506,7 @@ var init_SceneObject = __esm({
     import_ts_deepmerge3 = __toESM(require_dist());
     init_log();
     p6 = prefix("SceneObject");
-    _SceneObject = class _SceneObject extends import_three11.Object3D {
+    _SceneObject = class _SceneObject extends import_three12.Object3D {
       constructor(options) {
         super();
         this.isSceneObject = true;
@@ -3529,7 +3550,7 @@ var init_SceneObject = __esm({
         return group;
       }
       createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-        const obj = new import_three11.Object3D();
+        const obj = new import_three12.Object3D();
         if (name) {
           obj.name = `group:${name}`;
         }
@@ -3579,7 +3600,7 @@ var init_SceneObject = __esm({
         return mesh;
       }
       createMesh(name, geometry, material, offsetAxis, offset = 0) {
-        const mesh = new import_three11.Mesh(geometry, material);
+        const mesh = new import_three12.Mesh(geometry, material);
         if (name) {
           mesh.name = `mesh:${name}`;
         }
@@ -3591,7 +3612,7 @@ var init_SceneObject = __esm({
         return mesh;
       }
       createInstancedMesh(name, geometry, material, count) {
-        const mesh = new import_three11.InstancedMesh(geometry, material, count);
+        const mesh = new import_three12.InstancedMesh(geometry, material, count);
         mesh.count = 0;
         this.instanceMesh = mesh;
         this._isInstanced = true;
@@ -3671,11 +3692,11 @@ var init_SceneObject = __esm({
         this._instanceCounter = this.instanceReferences.size;
         mesh.count = Math.max(mesh.count, index + 1);
         if (mesh.instanceColor) {
-          mesh.setColorAt(index, new import_three11.Color(16777215));
+          mesh.setColorAt(index, new import_three12.Color(16777215));
           mesh.instanceColor.needsUpdate = true;
         }
         if (this._scene) this._scene.stats.instanceCount++;
-        this.setMatrixAt(index, new import_three11.Matrix4());
+        this.setMatrixAt(index, new import_three12.Matrix4());
         return reference;
       }
       /** Returns the live reference for a raycast hit on this object's instance mesh. */
@@ -3688,7 +3709,7 @@ var init_SceneObject = __esm({
       removeInstanceAt(index) {
         if (!this.instanceReferences.has(index)) return;
         const mesh = this.instanceMesh;
-        this.setMatrixAt(index, new import_three11.Matrix4().makeScale(0, 0, 0));
+        this.setMatrixAt(index, new import_three12.Matrix4().makeScale(0, 0, 0));
         this.instanceReferences.delete(index);
         this.freeInstanceIndices.push(index);
         this._instanceCounter = this.instanceReferences.size;
@@ -3701,7 +3722,7 @@ var init_SceneObject = __esm({
         const grow = (attribute, fill) => {
           const array = new Float32Array(capacity * attribute.itemSize).fill(fill);
           array.set(attribute.array);
-          return new import_three11.InstancedBufferAttribute(array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute).setUsage(attribute.usage);
+          return new import_three12.InstancedBufferAttribute(array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute).setUsage(attribute.usage);
         };
         const matrix = grow(mesh.instanceMatrix, 0);
         const color = mesh.instanceColor ? grow(mesh.instanceColor, 1) : null;
@@ -3718,7 +3739,7 @@ var init_SceneObject = __esm({
       }
       //</editor-fold>
       //<editor-fold desc="TRANSFORMATION">
-      getMatrixAt(index, matrix = new import_three11.Matrix4()) {
+      getMatrixAt(index, matrix = new import_three12.Matrix4()) {
         if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
         this.instanceMesh.getMatrixAt(index, matrix);
         return matrix;
@@ -3734,16 +3755,16 @@ var init_SceneObject = __esm({
       }
       setPositionRotationScaleAt(index, position, rotation, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-        const oldPosition = new import_three11.Vector3();
-        const oldRotation = new import_three11.Quaternion();
-        const oldScale = new import_three11.Vector3();
-        const matrix = new import_three11.Matrix4();
+        const oldPosition = new import_three12.Vector3();
+        const oldRotation = new import_three12.Quaternion();
+        const oldScale = new import_three12.Vector3();
+        const matrix = new import_three12.Matrix4();
         if (!scale || !rotation || !position) {
           this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
         }
         matrix.compose(
           position ? position : oldPosition,
-          rotation ? new import_three11.Quaternion().setFromEuler(rotation) : oldRotation,
+          rotation ? new import_three12.Quaternion().setFromEuler(rotation) : oldRotation,
           scale ? scale : oldScale
         );
         this.setMatrixAt(index, matrix);
@@ -3752,7 +3773,7 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, position);
       }
-      getPositionAt(index, vector = new import_three11.Vector3()) {
+      getPositionAt(index, vector = new import_three12.Vector3()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixPosition(matrix);
@@ -3762,17 +3783,17 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
       }
-      getRotationAt(index, euler = new import_three11.Euler()) {
+      getRotationAt(index, euler = new import_three12.Euler()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-        const rotation = new import_three11.Quaternion();
-        this.getMatrixAt(index).decompose(new import_three11.Vector3(), rotation, new import_three11.Vector3());
+        const rotation = new import_three12.Quaternion();
+        this.getMatrixAt(index).decompose(new import_three12.Vector3(), rotation, new import_three12.Vector3());
         return euler.setFromQuaternion(rotation);
       }
       setScaleAt(index, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, void 0, scale);
       }
-      getScaleAt(index, vector = new import_three11.Vector3()) {
+      getScaleAt(index, vector = new import_three12.Vector3()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixScale(matrix);
@@ -3907,13 +3928,13 @@ var init_SceneObject = __esm({
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
-var import_ts_deepmerge4, import_three13, _EntityObject, EntityObject;
+var import_ts_deepmerge4, import_three14, _EntityObject, EntityObject;
 var init_EntityObject = __esm({
   "src/entity/scene/EntityObject.ts"() {
     init_SceneObject();
     init_Caching();
     import_ts_deepmerge4 = __toESM(require_dist());
-    import_three13 = require("three");
+    import_three14 = require("three");
     init_Ticker();
     init_model();
     init_ModelTextures();
@@ -3934,7 +3955,8 @@ var init_EntityObject = __esm({
         this.scrollMaterials = [];
         /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
         this.age = 0;
-        this.animationPlayer = new EntityAnimationPlayer();
+        this.animationPlayers = [];
+        this.partPoses = /* @__PURE__ */ new Map();
         this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
         this.addEventListener("added", () => this.updateScrollSubscription());
         this.addEventListener("removed", () => this.updateScrollSubscription());
@@ -3951,7 +3973,8 @@ var init_EntityObject = __esm({
         for (const geometry of this.geometries) geometry.dispose();
         this.geometries.clear();
         for (const dispose of this.disposeWireframes.splice(0)) dispose();
-        this.animationPlayer.clear();
+        for (const player of this.animationPlayers.splice(0)) player.clear();
+        this.partPoses.clear();
         super.disposeAndRemoveAllChildren();
       }
       clearScrollMaterials() {
@@ -3983,36 +4006,61 @@ var init_EntityObject = __esm({
         this.notifyDirty();
       }
       //<editor-fold desc="ANIMATION">
-      /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+      /** The first active clip, until playback is stopped or the object is disposed. */
       get animation() {
-        return this.animationPlayer.animation;
+        return this.animationPlayers[0]?.animation;
+      }
+      /** Clips playing together, each targeting a separate geometry layer. */
+      get activeAnimations() {
+        return this.animationPlayers.map((player) => player.animation);
       }
       /** Seconds since the animation started, before looping. */
       get animationTime() {
-        return this.animationPlayer.time;
+        return this.animationPlayers[0]?.time ?? 0;
       }
       /**
-       * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
-       * Parts of every layer are matched by name and their current pose is the default the offsets add to.
+       * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
+       * Offsets apply to the baked pose in the clip's layer (`main` by default), including repeated draws of that layer.
        * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
        */
       playAnimation(animation, options) {
+        this.playAnimations([animation], options);
+      }
+      /** Plays one clip per selected geometry layer, with a shared clock and no blending between clips. */
+      playAnimations(animations, options) {
+        const targets = /* @__PURE__ */ new Set();
+        const selections = animations.map((animation) => {
+          const layer = animation.layer ?? "main";
+          if (targets.has(layer)) throw new Error(`Multiple animations target layer "${layer}"`);
+          targets.add(layer);
+          const names = Object.keys(this.entityLayers).filter((name) => name.split("#")[0] === layer);
+          if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
+          return { animation, names };
+        });
         this.createMeshes();
-        const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
-        this.animationPlayer.play(layers, animation, options);
+        this.stopAnimation();
+        for (const { animation, names } of selections) {
+          const player = new EntityAnimationPlayer();
+          player.play(names.map((name) => this.getLayerGroup(name)), animation, options, this.partPoses);
+          this.animationPlayers.push(player);
+        }
         this.notifyDirty();
       }
-      /** Stops the animation and restores the default pose. */
+      /** Stops all clips and restores the poses from before playback. */
       stopAnimation() {
-        if (this.animationPlayer.stop()) this.notifyDirty();
+        const players = this.animationPlayers.splice(0);
+        for (const player of players) player.stop();
+        if (players.length) this.notifyDirty();
       }
       /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
       setAnimationTime(seconds) {
-        if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
+        for (const player of this.animationPlayers) player.setTime(seconds);
+        if (this.animationPlayers.length) this.notifyDirty();
       }
       /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
       advanceAnimation(deltaSeconds) {
-        if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
+        for (const player of this.animationPlayers) player.advance(deltaSeconds);
+        if (this.animationPlayers.length) this.notifyDirty();
       }
       //</editor-fold>
       getLayerGroup(name) {
@@ -4044,14 +4092,14 @@ var init_EntityObject = __esm({
       }
       createMeshes(force = false) {
         if (this.meshesCreated && !force) return;
-        const modelRoot = new import_three13.Object3D();
+        const modelRoot = new import_three14.Object3D();
         const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
         if (transform) {
           for (const op of transform) {
-            const matrix = new import_three13.Matrix4();
+            const matrix = new import_three14.Matrix4();
             if ("scale" in op) matrix.makeScale(...op.scale);
             else if ("translate" in op) matrix.makeTranslation(...op.translate);
-            else matrix.makeRotationFromEuler(new import_three13.Euler(...op.rotate, "ZYX"));
+            else matrix.makeRotationFromEuler(new import_three14.Euler(...op.rotate, "ZYX"));
             modelRoot.matrix.multiply(matrix);
           }
           modelRoot.matrixAutoUpdate = false;
@@ -4072,6 +4120,7 @@ var init_EntityObject = __esm({
         anchor.position.fromArray(part.pose.offset);
         anchor.rotation.set(...part.pose.rotation, "ZYX");
         anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+        this.partPoses.set(anchor, part.pose);
         parent.add(anchor);
         const size = part.texture ?? textureSize;
         for (const cube of part.cubes) {
@@ -4107,7 +4156,7 @@ var init_EntityObject = __esm({
           const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
           const scroll = Materials.entityModeScroll(mode);
           const assetKeyStr = this.getTextureKey(layer).serialize();
-          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three13.Color(tint).getHexString()}:${assetKeyStr}`;
+          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three14.Color(tint).getHexString()}:${assetKeyStr}`;
           let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
           if (!mat) {
             const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
@@ -4150,7 +4199,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three20.BufferGeometry();
+  const mergedGeometry = new import_three21.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4274,7 +4323,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three20.BufferAttribute(array, itemSize, normalized);
+  return new import_three21.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4290,7 +4339,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three20.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three21.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4299,7 +4348,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three20.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three21.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4383,13 +4432,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three20.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three21.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three20.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three21.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4398,11 +4447,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three20.TrianglesDrawMode) {
+  if (drawMode === import_three21.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three20.TriangleFanDrawMode || drawMode === import_three20.TriangleStripDrawMode) {
+  if (drawMode === import_three21.TriangleFanDrawMode || drawMode === import_three21.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4420,7 +4469,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three20.TriangleFanDrawMode) {
+    if (drawMode === import_three21.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4456,15 +4505,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three20.Vector3();
-  const _vB = new import_three20.Vector3();
-  const _vC = new import_three20.Vector3();
-  const _tempA = new import_three20.Vector3();
-  const _tempB = new import_three20.Vector3();
-  const _tempC = new import_three20.Vector3();
-  const _morphA = new import_three20.Vector3();
-  const _morphB = new import_three20.Vector3();
-  const _morphC = new import_three20.Vector3();
+  const _vA = new import_three21.Vector3();
+  const _vB = new import_three21.Vector3();
+  const _vC = new import_three21.Vector3();
+  const _tempA = new import_three21.Vector3();
+  const _tempB = new import_three21.Vector3();
+  const _tempC = new import_three21.Vector3();
+  const _morphA = new import_three21.Vector3();
+  const _morphB = new import_three21.Vector3();
+  const _morphC = new import_three21.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4659,8 +4708,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three20.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three20.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three21.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three21.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4668,24 +4717,24 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three20;
+var import_three21;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three20 = require("three");
+    import_three21 = require("three");
   }
 });
 
 // src/model/ModelCulling.ts
-var import_three21, ModelCulling;
+var import_three22, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three21 = require("three");
+    import_three22 = require("three");
     init_CubeFace();
     ModelCulling = class {
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three21.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three22.Vector3(...offset).applyEuler(rotation);
           const worldFace = 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);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -4718,10 +4767,10 @@ var init_ModelCulling = __esm({
 });
 
 // src/model/SpecialItems.ts
-var import_three22, SpecialItems;
+var import_three23, SpecialItems;
 var init_SpecialItems = __esm({
   "src/model/SpecialItems.ts"() {
-    import_three22 = require("three");
+    import_three23 = require("three");
     init_AssetKey();
     init_Entities();
     SpecialItems = class {
@@ -4749,7 +4798,7 @@ var init_SpecialItems = __esm({
           case "minecraft:chest":
           case "chest": {
             const angle = -(special.openness ?? 0) * Math.PI / 2;
-            const chest = await load("chest", texture(special.texture, "chest"), new import_three22.Matrix4(), {
+            const chest = await load("chest", texture(special.texture, "chest"), new import_three23.Matrix4(), {
               lid: [angle, 0, 0],
               lock: [angle, 0, 0]
             });
@@ -4758,11 +4807,11 @@ var init_SpecialItems = __esm({
           }
           case "minecraft:bed":
           case "bed": {
-            const transform = new import_three22.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three22.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three22.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three22.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
+            const transform = new import_three23.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three23.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three23.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three23.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
             const key = texture(special.texture, "bed");
             return Promise.all([
               load("bed_head", key, transform),
-              load("bed_foot", key, new import_three22.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
+              load("bed_foot", key, new import_three23.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
             ]);
           }
           case "minecraft:head":
@@ -4787,7 +4836,7 @@ var init_SpecialItems = __esm({
             return [await load(
               id,
               special.texture ? texture(special.texture, "") : void 0,
-              new import_three22.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three22.Matrix4().makeScale(-1, -1, 1)),
+              new import_three23.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three23.Matrix4().makeScale(-1, -1, 1)),
               rotations
             )];
           }
@@ -4830,17 +4879,98 @@ var init_GuiLight = __esm({
   }
 });
 
+// src/texture/Colormaps.ts
+var Colormaps;
+var init_Colormaps = __esm({
+  "src/texture/Colormaps.ts"() {
+    init_AssetKey();
+    init_ModelTextures();
+    init_Caching();
+    init_MineRenderError();
+    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);
+        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.width !== 256 || image.height !== 256) {
+            throw new MineRenderError("Grass 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;
+        });
+      }
+    };
+  }
+});
+
+// src/model/ItemTints.ts
+var ItemTints;
+var init_ItemTints = __esm({
+  "src/model/ItemTints.ts"() {
+    init_MineRenderError();
+    init_Colormaps();
+    ItemTints = class {
+      /** Resolves preview colors from item definitions; explicit per-index colors take precedence. */
+      static async get(model, tints) {
+        const sources = model.tints;
+        if (!sources?.length) return tints;
+        const colors = { ...tints };
+        await Promise.all(sources.map(async (source, index) => {
+          if (colors[index] !== void 0) return;
+          switch (source.type) {
+            case "constant":
+            case "minecraft:constant":
+              colors[index] = this.rgb(source.value);
+              break;
+            case "grass":
+            case "minecraft:grass":
+              colors[index] = await Colormaps.grassColor(model.key, source.temperature, source.downfall);
+              break;
+            case "dye":
+            case "minecraft:dye":
+            case "potion":
+            case "minecraft:potion":
+            case "map_color":
+            case "minecraft:map_color":
+            case "firework":
+            case "minecraft:firework":
+            case "team":
+            case "minecraft:team":
+            case "custom_model_data":
+            case "minecraft:custom_model_data":
+              colors[index] = this.rgb(source.default);
+              break;
+            default:
+              throw new MineRenderError(`Unsupported item tint source ${source.type}`);
+          }
+        }));
+        return colors;
+      }
+      static rgb(color) {
+        if (!Array.isArray(color)) return color & 16777215;
+        const [red, green, blue] = color.map((channel) => Math.floor(Math.fround(Math.fround(channel) * 255)));
+        return red << 16 | green << 8 | blue;
+      }
+    };
+  }
+});
+
 // src/model/scene/ModelObject.ts
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three23, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
+var import_three24, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three23 = require("three");
+    import_three24 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4852,6 +4982,7 @@ var init_ModelObject = __esm({
     init_SpecialItems();
     init_EntityObject();
     init_GuiLight();
+    init_ItemTints();
     p7 = prefix("ModelObject");
     _ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
@@ -4867,11 +4998,12 @@ var init_ModelObject = __esm({
         this.addEventListener("removed", () => this.updateAnimationSubscription());
       }
       async init() {
+        this.options.tints = await ItemTints.get(this.originalModel, this.options.tints);
         const special = this.originalModel.special;
         if (special) {
           const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
-          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three23.Matrix4();
-          transform.multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three24.Matrix4();
+          transform.multiply(new import_three24.Matrix4().makeTranslation(-8, -8, -8));
           try {
             for (const part of parts) {
               const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
@@ -4933,7 +5065,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three23.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three24.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4942,19 +5074,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three23.Color(tint);
+                  const color = new import_three24.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three23.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three24.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three24.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three24.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three24.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4976,7 +5108,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three23.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three24.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -5088,7 +5220,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three28.BufferGeometry();
+  const geometry = new import_three29.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -5187,16 +5319,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three28.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three28.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three28.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three29.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three29.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three29.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three28, fluidRules, HORIZONTAL, EPSILON;
+var import_three29, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three28 = require("three");
+    import_three29 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -5225,10 +5357,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three29, FluidModelObject;
+var import_three30, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three29 = require("three");
+    import_three30 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -5261,10 +5393,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three29.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three30.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new import_three29.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three30.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -5278,7 +5410,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three29.DoubleSide;
+          material.side = import_three30.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -5323,6 +5455,7 @@ __export(index_browser_exports, {
   CanvasImage: () => CanvasImage,
   Chunk: () => Chunk,
   ChunkData: () => ChunkData,
+  Colormaps: () => Colormaps,
   CubeFace: () => CubeFace,
   CubeFaceIndex: () => CubeFaceIndex,
   DEFAULT_ELEMENTS: () => DEFAULT_ELEMENTS,
@@ -5348,6 +5481,7 @@ __export(index_browser_exports, {
   ImageLoader: () => ImageLoader,
   InstanceManager: () => InstanceManager,
   InstanceReference: () => InstanceReference,
+  ItemTints: () => ItemTints,
   MapControls: () => MapControls,
   Materials: () => Materials,
   Meshes: () => Meshes,
@@ -5763,27 +5897,27 @@ init_EntityObject();
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-var import_three19 = require("three");
+var import_three20 = require("three");
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
-var import_three15 = require("three");
+var import_three16 = require("three");
 var OBJExporter = class {
   parse(object) {
     let output = "";
     let indexVertex = 0;
     let indexVertexUvs = 0;
     let indexNormals = 0;
-    const vertex = new import_three15.Vector3();
-    const color = new import_three15.Color();
-    const normal = new import_three15.Vector3();
-    const uv = new import_three15.Vector2();
+    const vertex = new import_three16.Vector3();
+    const color = new import_three16.Color();
+    const normal = new import_three16.Vector3();
+    const uv = new import_three16.Vector2();
     const face = [];
     function parseMesh(mesh) {
       let nbVertex = 0;
       let nbNormals = 0;
       let nbVertexUvs = 0;
       const geometry = mesh.geometry;
-      const normalMatrixWorld = new import_three15.Matrix3();
+      const normalMatrixWorld = new import_three16.Matrix3();
       const vertices = geometry.getAttribute("position");
       const normals = geometry.getAttribute("normal");
       const uvs = geometry.getAttribute("uv");
@@ -5902,7 +6036,7 @@ var OBJExporter = class {
 };
 
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
-var import_three16 = require("three");
+var import_three17 = require("three");
 var PLYExporter = class {
   parse(object, onDone, options = {}) {
     function traverseMeshes(cb) {
@@ -5959,7 +6093,7 @@ var PLYExporter = class {
         includeIndices = false;
       }
     });
-    const tempColor = new import_three16.Color();
+    const tempColor = new import_three17.Color();
     includeIndices = includeIndices && excludeAttributes.indexOf("index") === -1;
     includeNormals = includeNormals && excludeAttributes.indexOf("normal") === -1;
     includeColors = includeColors && excludeAttributes.indexOf("color") === -1;
@@ -5993,8 +6127,8 @@ property list uchar int vertex_index
 `;
     }
     header += "end_header\n";
-    const vertex = new import_three16.Vector3();
-    const normalMatrixWorld = new import_three16.Matrix3();
+    const vertex = new import_three17.Vector3();
+    const normalMatrixWorld = new import_three17.Matrix3();
     let result = null;
     if (options.binary === true) {
       const headerBin = new TextEncoder().encode(header);
@@ -6168,18 +6302,18 @@ property list uchar int vertex_index
 };
 
 // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
-var import_three18 = require("three");
+var import_three19 = require("three");
 
 // ../../node_modules/three/examples/jsm/utils/TextureUtils.js
-var import_three17 = require("three");
+var import_three18 = require("three");
 var _renderer;
 var fullscreenQuadGeometry;
 var fullscreenQuadMaterial;
 var fullscreenQuad;
 function decompress(texture, maxTextureSize = Infinity, renderer = null) {
-  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three17.PlaneGeometry(2, 2, 1, 1);
-  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three17.ShaderMaterial({
-    uniforms: { blitTexture: new import_three17.Uniform(texture) },
+  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three18.PlaneGeometry(2, 2, 1, 1);
+  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three18.ShaderMaterial({
+    uniforms: { blitTexture: new import_three18.Uniform(texture) },
     vertexShader: `
             varying vec2 vUv;
             void main(){
@@ -6201,22 +6335,22 @@ function decompress(texture, maxTextureSize = Infinity, renderer = null) {
             }`
   });
   fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
-  fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == import_three17.SRGBColorSpace;
+  fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == import_three18.SRGBColorSpace;
   fullscreenQuadMaterial.needsUpdate = true;
   if (!fullscreenQuad) {
-    fullscreenQuad = new import_three17.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
+    fullscreenQuad = new import_three18.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
     fullscreenQuad.frustrumCulled = false;
   }
-  const _camera = new import_three17.PerspectiveCamera();
-  const _scene = new import_three17.Scene();
+  const _camera = new import_three18.PerspectiveCamera();
+  const _scene = new import_three18.Scene();
   _scene.add(fullscreenQuad);
   if (!renderer) {
-    renderer = _renderer = new import_three17.WebGLRenderer({ antialias: false });
+    renderer = _renderer = new import_three18.WebGLRenderer({ antialias: false });
   }
   renderer.setSize(Math.min(texture.image.width, maxTextureSize), Math.min(texture.image.height, maxTextureSize));
   renderer.clear();
   renderer.render(_scene, _camera);
-  const readableTexture = new import_three17.Texture(renderer.domElement);
+  const readableTexture = new import_three18.Texture(renderer.domElement);
   readableTexture.minFilter = texture.minFilter;
   readableTexture.magFilter = texture.magFilter;
   readableTexture.wrapS = texture.wrapS;
@@ -6362,22 +6496,22 @@ var WEBGL_CONSTANTS = {
 };
 var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
 var THREE_TO_WEBGL = {};
-THREE_TO_WEBGL[import_three18.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
-THREE_TO_WEBGL[import_three18.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three18.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three18.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
-THREE_TO_WEBGL[import_three18.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three18.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three18.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-THREE_TO_WEBGL[import_three18.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
-THREE_TO_WEBGL[import_three18.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+THREE_TO_WEBGL[import_three19.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[import_three19.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three19.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three19.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[import_three19.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three19.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three19.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[import_three19.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[import_three19.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
 var PATH_PROPERTIES = {
   scale: "scale",
   position: "translation",
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
-var DEFAULT_SPECULAR_COLOR = new import_three18.Color();
+var DEFAULT_SPECULAR_COLOR = new import_three19.Color();
 var GLB_HEADER_BYTES = 12;
 var GLB_HEADER_MAGIC = 1179937895;
 var GLB_VERSION = 2;
@@ -6411,7 +6545,7 @@ function getMinMax(attribute, start, count) {
         else if (a === 2) value = attribute.getZ(i);
         else if (a === 3) value = attribute.getW(i);
         if (attribute.normalized === true) {
-          value = import_three18.MathUtils.normalize(value, attribute.array);
+          value = import_three19.MathUtils.normalize(value, attribute.array);
         }
       }
       output.min[a] = Math.min(output.min[a], value);
@@ -6617,7 +6751,7 @@ var GLTFWriter = class {
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new import_three18.Vector3();
+    const v = new import_three19.Vector3();
     for (let i = 0, il = normal.count; i < il; i++) {
       if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
     }
@@ -6634,7 +6768,7 @@ var GLTFWriter = class {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
     const attribute = normal.clone();
-    const v = new import_three18.Vector3();
+    const v = new import_three19.Vector3();
     for (let i = 0, il = attribute.count; i < il; i++) {
       v.fromBufferAttribute(attribute, i);
       if (v.x === 0 && v.y === 0 && v.z === 0) {
@@ -6678,7 +6812,7 @@ var GLTFWriter = class {
   buildMetalRoughTexture(metalnessMap, roughnessMap) {
     if (metalnessMap === roughnessMap) return metalnessMap;
     function getEncodingConversion(map) {
-      if (map.colorSpace === import_three18.SRGBColorSpace) {
+      if (map.colorSpace === import_three19.SRGBColorSpace) {
         return function SRGBToLinear(c) {
           return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
         };
@@ -6688,10 +6822,10 @@ var GLTFWriter = class {
       };
     }
     console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
-    if (metalnessMap instanceof import_three18.CompressedTexture) {
+    if (metalnessMap instanceof import_three19.CompressedTexture) {
       metalnessMap = decompress(metalnessMap);
     }
-    if (roughnessMap instanceof import_three18.CompressedTexture) {
+    if (roughnessMap instanceof import_three19.CompressedTexture) {
       roughnessMap = decompress(roughnessMap);
     }
     const metalness = metalnessMap ? metalnessMap.image : null;
@@ -6724,8 +6858,8 @@ var GLTFWriter = class {
     context.putImageData(composite, 0, 0);
     const reference = metalnessMap || roughnessMap;
     const texture = reference.clone();
-    texture.source = new import_three18.Source(canvas);
-    texture.colorSpace = import_three18.NoColorSpace;
+    texture.source = new import_three19.Source(canvas);
+    texture.colorSpace = import_three19.NoColorSpace;
     texture.channel = (metalnessMap || roughnessMap).channel;
     if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
       console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.");
@@ -6783,7 +6917,7 @@ var GLTFWriter = class {
           else if (a === 2) value = attribute.getZ(i);
           else if (a === 3) value = attribute.getW(i);
           if (attribute.normalized === true) {
-            value = import_three18.MathUtils.normalize(value, attribute.array);
+            value = import_three19.MathUtils.normalize(value, attribute.array);
           }
         }
         if (componentType === WEBGL_CONSTANTS.FLOAT) {
@@ -6933,7 +7067,7 @@ var GLTFWriter = class {
         ctx.scale(1, -1);
       }
       if (image.data !== void 0) {
-        if (format !== import_three18.RGBAFormat) {
+        if (format !== import_three19.RGBAFormat) {
           console.error("GLTFExporter: Only RGBAFormat is supported.", format);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
@@ -7002,7 +7136,7 @@ var GLTFWriter = class {
     const json = this.json;
     if (cache.textures.has(map)) return cache.textures.get(map);
     if (!json.textures) json.textures = [];
-    if (map instanceof import_three18.CompressedTexture) {
+    if (map instanceof import_three19.CompressedTexture) {
       map = decompress(map, options.maxTextureSize);
     }
     let mimeType = map.userData.mimeType;
@@ -7110,7 +7244,7 @@ var GLTFWriter = class {
         materialDef.alphaCutoff = material.alphaTest;
       }
     }
-    if (material.side === import_three18.DoubleSide) materialDef.doubleSided = true;
+    if (material.side === import_three19.DoubleSide) materialDef.doubleSided = true;
     if (material.name !== "") materialDef.name = material.name;
     this.serializeUserData(material, materialDef);
     this._invokeAll(function(ext) {
@@ -7184,7 +7318,7 @@ var GLTFWriter = class {
       const array = attribute.array;
       if (attributeName === "JOINTS_0" && !(array instanceof Uint16Array) && !(array instanceof Uint8Array)) {
         console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
-        modifiedAttribute = new import_three18.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+        modifiedAttribute = new import_three19.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
       }
       const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
       if (accessor !== null) {
@@ -7344,7 +7478,7 @@ var GLTFWriter = class {
     } else {
       cameraDef.perspective = {
         aspectRatio: camera.aspect,
-        yfov: import_three18.MathUtils.degToRad(camera.fov),
+        yfov: import_three19.MathUtils.degToRad(camera.fov),
         zfar: camera.far <= 0 ? 1e-3 : camera.far,
         znear: camera.near < 0 ? 0 : camera.near
       };
@@ -7372,8 +7506,8 @@ var GLTFWriter = class {
     const samplers = [];
     for (let i = 0; i < tracks.length; ++i) {
       const track = tracks[i];
-      const trackBinding = import_three18.PropertyBinding.parseTrackName(track.name);
-      let trackNode = import_three18.PropertyBinding.findNode(root, trackBinding.nodeName);
+      const trackBinding = import_three19.PropertyBinding.parseTrackName(track.name);
+      let trackNode = import_three19.PropertyBinding.findNode(root, trackBinding.nodeName);
       const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
       if (trackBinding.objectName === "bones") {
         if (trackNode.isSkinnedMesh === true) {
@@ -7395,14 +7529,14 @@ var GLTFWriter = class {
       if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
         interpolation = "CUBICSPLINE";
         outputItemSize /= 3;
-      } else if (track.getInterpolation() === import_three18.InterpolateDiscrete) {
+      } else if (track.getInterpolation() === import_three19.InterpolateDiscrete) {
         interpolation = "STEP";
       } else {
         interpolation = "LINEAR";
       }
       samplers.push({
-        input: this.processAccessor(new import_three18.BufferAttribute(track.times, inputItemSize)),
-        output: this.processAccessor(new import_three18.BufferAttribute(track.values, outputItemSize)),
+        input: this.processAccessor(new import_three19.BufferAttribute(track.times, inputItemSize)),
+        output: this.processAccessor(new import_three19.BufferAttribute(track.values, outputItemSize)),
         interpolation
       });
       channels.push({
@@ -7434,7 +7568,7 @@ var GLTFWriter = class {
     if (rootJoint === void 0) return null;
     const joints = [];
     const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-    const temporaryBoneInverse = new import_three18.Matrix4();
+    const temporaryBoneInverse = new import_three19.Matrix4();
     for (let i = 0; i < skeleton.bones.length; ++i) {
       joints.push(nodeMap.get(skeleton.bones[i]));
       temporaryBoneInverse.copy(skeleton.boneInverses[i]);
@@ -7442,7 +7576,7 @@ var GLTFWriter = class {
     }
     if (json.skins === void 0) json.skins = [];
     json.skins.push({
-      inverseBindMatrices: this.processAccessor(new import_three18.BufferAttribute(inverseBindMatrices, 16)),
+      inverseBindMatrices: this.processAccessor(new import_three19.BufferAttribute(inverseBindMatrices, 16)),
       joints,
       skeleton: nodeMap.get(rootJoint)
     });
@@ -7538,7 +7672,7 @@ var GLTFWriter = class {
    * @param  {Array} objects List of objects to process
    */
   processObjects(objects) {
-    const scene = new import_three18.Scene();
+    const scene = new import_three19.Scene();
     scene.name = "AuxScene";
     for (let i = 0; i < objects.length; i++) {
       scene.children.push(objects[i]);
@@ -7556,7 +7690,7 @@ var GLTFWriter = class {
     });
     const objectsWithoutScene = [];
     for (let i = 0; i < input.length; i++) {
-      if (input[i] instanceof import_three18.Scene) {
+      if (input[i] instanceof import_three19.Scene) {
         this.processScene(input[i]);
       } else {
         objectsWithoutScene.push(input[i]);
@@ -7900,10 +8034,10 @@ var GLTFMeshGpuInstancing = class {
     const translationAttr = new Float32Array(mesh.count * 3);
     const rotationAttr = new Float32Array(mesh.count * 4);
     const scaleAttr = new Float32Array(mesh.count * 3);
-    const matrix = new import_three18.Matrix4();
-    const position = new import_three18.Vector3();
-    const quaternion = new import_three18.Quaternion();
-    const scale = new import_three18.Vector3();
+    const matrix = new import_three19.Matrix4();
+    const position = new import_three19.Vector3();
+    const quaternion = new import_three19.Quaternion();
+    const scale = new import_three19.Vector3();
     for (let i = 0; i < mesh.count; i++) {
       mesh.getMatrixAt(i, matrix);
       matrix.decompose(position, quaternion, scale);
@@ -7912,9 +8046,9 @@ var GLTFMeshGpuInstancing = class {
       scale.toArray(scaleAttr, i * 3);
     }
     const attributes = {
-      TRANSLATION: writer.processAccessor(new import_three18.BufferAttribute(translationAttr, 3)),
-      ROTATION: writer.processAccessor(new import_three18.BufferAttribute(rotationAttr, 4)),
-      SCALE: writer.processAccessor(new import_three18.BufferAttribute(scaleAttr, 3))
+      TRANSLATION: writer.processAccessor(new import_three19.BufferAttribute(translationAttr, 3)),
+      ROTATION: writer.processAccessor(new import_three19.BufferAttribute(rotationAttr, 4)),
+      SCALE: writer.processAccessor(new import_three19.BufferAttribute(scaleAttr, 3))
     };
     if (mesh.instanceColor)
       attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
@@ -7979,8 +8113,8 @@ GLTFExporter.Utils = {
     const sourceTracks = clip.tracks;
     for (let i = 0; i < sourceTracks.length; ++i) {
       let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = import_three18.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = import_three18.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      const sourceTrackBinding = import_three19.PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = import_three19.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
       if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
         tracks.push(sourceTrack);
         continue;
@@ -7991,7 +8125,7 @@ GLTFExporter.Utils = {
         }
         console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
         sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(import_three18.InterpolateLinear);
+        sourceTrack.setInterpolation(import_three19.InterpolateLinear);
       }
       const targetCount = sourceTrackNode.morphTargetInfluences.length;
       const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
@@ -8074,10 +8208,10 @@ var SceneExporter = class {
   }
 };
 function localMatrix(object) {
-  return object.matrixAutoUpdate ? new import_three19.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+  return object.matrixAutoUpdate ? new import_three20.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
 }
 function createSnapshot(root, gltf, bakeColors = false) {
-  const scene = new import_three19.Scene();
+  const scene = new import_three20.Scene();
   const geometries = [];
   const materials = [];
   const textures = [];
@@ -8095,7 +8229,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       if (!uniforms.map?.value?.isTexture || !uniforms.SHADE || !uniforms.BRIGHTNESS || !uniforms.EMISSIVE) {
         throw new MineRenderError("glTF export does not support this custom ShaderMaterial");
       }
-      material = new import_three19.MeshBasicMaterial({
+      material = new import_three20.MeshBasicMaterial({
         map: uniforms.map.value,
         vertexColors: source.vertexColors,
         transparent: source.transparent,
@@ -8105,7 +8239,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       });
       material.name = source.name;
     } else if (shader.isShaderMaterial) {
-      material = new import_three19.MeshBasicMaterial({ vertexColors: source.vertexColors });
+      material = new import_three20.MeshBasicMaterial({ vertexColors: source.vertexColors });
       material.name = source.name;
     } else {
       const copySource = Object.create(source);
@@ -8159,11 +8293,11 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const material = copyMaterial(sourceMaterial, geometry);
       if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
       if (bakeColors || instanceColor) {
-        const tint = (material.color ?? new import_three19.Color()).clone();
+        const tint = (material.color ?? new import_three20.Color()).clone();
         if (instanceColor) tint.multiply(instanceColor);
         if (bakeColors) {
           const original = geometry.getAttribute("color");
-          const colors = new import_three19.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          const colors = new import_three20.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
           for (let i = 0; i < colors.count; i++) {
             colors.setXYZ(i, (original?.getX(i) ?? 1) * tint.r, (original?.getY(i) ?? 1) * tint.g, (original?.getZ(i) ?? 1) * tint.b);
           }
@@ -8172,7 +8306,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new import_three19.Mesh(geometry, material);
+      const copy = new import_three20.Mesh(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -8186,9 +8320,9 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const instanced = mesh;
       if (instanced.isInstancedMesh) {
         for (let i = 0; i < instanced.count; i++) {
-          const matrix = new import_three19.Matrix4();
+          const matrix = new import_three20.Matrix4();
           instanced.getMatrixAt(i, matrix);
-          const color = instanced.instanceColor ? new import_three19.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          const color = instanced.instanceColor ? new import_three20.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
           addMesh(mesh, world.clone().multiply(matrix), color);
         }
       } else {
@@ -8200,7 +8334,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
   try {
     const ancestors = [];
     for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
-    const world = new import_three19.Matrix4();
+    const world = new import_three20.Matrix4();
     for (const ancestor of ancestors) {
       if (!ancestor.visible) return { scene, dispose };
       world.multiply(localMatrix(ancestor));
@@ -8214,7 +8348,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
 }
 function selectAlphaMode(material, geometry) {
   const texture = material.map;
-  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three19.RGBAFormat || texture.type !== import_three19.UnsignedByteType || texture.wrapS !== import_three19.ClampToEdgeWrapping || texture.wrapT !== import_three19.ClampToEdgeWrapping || texture.magFilter !== import_three19.NearestFilter || texture.minFilter !== import_three19.NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
+  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three20.RGBAFormat || texture.type !== import_three20.UnsignedByteType || texture.wrapS !== import_three20.ClampToEdgeWrapping || texture.wrapT !== import_three20.ClampToEdgeWrapping || texture.magFilter !== import_three20.NearestFilter || texture.minFilter !== import_three20.NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
   const uv = geometry.getAttribute(texture.channel === 0 ? "uv" : `uv${texture.channel}`);
   const colors = geometry.getAttribute("color");
   if (!uv || material.vertexColors && colors?.itemSize === 4) return;
@@ -8251,7 +8385,7 @@ function selectAlphaMode(material, geometry) {
 }
 function copyDataTexture(source) {
   const image = source.image;
-  if (source.format !== import_three19.RGBAFormat || source.type !== import_three19.UnsignedByteType) {
+  if (source.format !== import_three20.RGBAFormat || source.type !== import_three20.UnsignedByteType) {
     throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
   }
   const canvas = createCanvas(image.width, image.height);
@@ -8262,8 +8396,8 @@ function copyDataTexture(source) {
   context.putImageData(pixels, 0, 0);
   const copySource = Object.create(source);
   copySource.userData = {};
-  copySource.source = new import_three19.Source(canvas);
-  return new import_three19.Texture().copy(copySource);
+  copySource.source = new import_three20.Source(canvas);
+  return new import_three20.Texture().copy(copySource);
 }
 
 // src/gui/GuiHelper.ts
@@ -8333,7 +8467,7 @@ var GuiHelper = class {
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three24 = require("three");
+var import_three25 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Models();
@@ -8349,7 +8483,7 @@ var GuiObject = class extends SceneObject {
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three24.Box2();
+    this.bounds = new import_three25.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -8367,17 +8501,17 @@ var GuiObject = class extends SceneObject {
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
           item.updateWorldMatrix(true, true);
           const inverse = this.matrixWorld.clone().invert();
-          const bounds = new import_three24.Box3();
+          const bounds = new import_three25.Box3();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
-            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three24.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
+            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three25.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
           });
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
-          this.bounds.expandByPoint(new import_three24.Vector2(x, y));
-          this.bounds.expandByPoint(new import_three24.Vector2(x + width2, y + height2));
-          this.bounds.expandByPoint(new import_three24.Vector2(bounds.min.x, -bounds.max.y));
-          this.bounds.expandByPoint(new import_three24.Vector2(bounds.max.x, -bounds.min.y));
+          this.bounds.expandByPoint(new import_three25.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three25.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three25.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three25.Vector2(bounds.max.x, -bounds.min.y));
           continue;
         }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
@@ -8385,7 +8519,7 @@ var GuiObject = class extends SceneObject {
         const image = material.map.image;
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new import_three24.PlaneGeometry(width, height);
+        const geometry = new import_three25.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -8395,13 +8529,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three24.Mesh(geometry, material);
+        const mesh = new import_three25.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three24.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three24.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three25.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three25.Vector2(x + width, y + height));
         depth += 0.01;
       }
       for (const child of this.children) child.position.z -= depth - 0.01;
@@ -8476,7 +8610,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three25 = require("three");
+var import_three26 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -8486,11 +8620,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three25.Vector2();
+    this.mouse = new import_three26.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three25.Raycaster();
+    this.raycaster = new import_three26.Raycaster();
     this.init();
   }
   init() {
@@ -8885,6 +9019,7 @@ function isInstanceable(obj) {
 init_DisplayPosition();
 init_DisplayTransforms();
 init_GuiLight();
+init_ItemTints();
 init_Model();
 init_ModelCulling();
 init_ModelGenerator();
@@ -8892,7 +9027,7 @@ init_ModelMerger();
 init_SpecialItems();
 
 // src/model/block/BlockStateResolver.ts
-var import_three27 = require("three");
+var import_three28 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -8970,7 +9105,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three27.Euler();
+    const rotation = new import_three28.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -8982,10 +9117,7 @@ var BlockStateResolver = class {
 };
 
 // src/model/block/BlockTints.ts
-init_AssetKey();
-init_ModelTextures();
-init_Caching();
-init_MineRenderError();
+init_Colormaps();
 
 // src/model/block/blockTints.json
 var blockTints_default = {
@@ -9040,7 +9172,7 @@ var BlockTints = class {
         color = rule.color;
         break;
       case "grass":
-        color = await this.grassColor(key);
+        color = await Colormaps.grassColor(key);
         break;
       case "redstone": {
         const power = Number(state.power ?? 0) / 15;
@@ -9058,18 +9190,6 @@ var BlockTints = class {
     }
     return { ...Object.fromEntries([...indices].map((index) => [index, color])), ...tints };
   }
-  static async grassColor(origin) {
-    const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
-    return await Caching.blockTintCache.get(key.serialize(), async () => {
-      const image = await ModelTextures.get(key);
-      if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
-      if (image.width !== 256 || image.height !== 256) {
-        throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
-      }
-      const [red, green, blue] = image.data.getImageData(127, 127, 1, 1).data;
-      return red << 16 | green << 8 | blue;
-    });
-  }
 };
 
 // src/model/block/scene/BlockObject.ts
@@ -9077,7 +9197,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three30 = require("three");
+var import_three31 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -9099,7 +9219,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._models = [];
     this._cullMask = 0;
     this._entities = [];
-    this._entityPlacement = new import_three30.Matrix4();
+    this._entityPlacement = new import_three31.Matrix4();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
@@ -9179,7 +9299,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     return true;
   }
   placeEntities() {
-    const matrix = new import_three30.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+    const matrix = new import_three31.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
     for (const entity of this._entities) {
       matrix.decompose(entity.position, entity.quaternion, entity.scale);
     }
@@ -9198,12 +9318,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new import_three30.Vector3();
-    const rotation = new import_three30.Quaternion();
-    const scale = new import_three30.Vector3();
+    const position = new import_three31.Vector3();
+    const rotation = new import_three31.Quaternion();
+    const scale = new import_three31.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three30.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three30.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three31.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three31.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -9265,7 +9385,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new import_three30.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three31.Matrix4().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -9403,7 +9523,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three30.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three31.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -11274,7 +11394,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three32 = require("three");
+var import_three33 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -12007,7 +12127,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three31 = require("three");
+var import_three32 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -12091,11 +12211,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three31.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three31.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three32.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three32.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three31.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three31.DoubleSide : import_three31.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three32.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three32.DoubleSide : import_three32.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -12324,7 +12444,8 @@ var SkinObject = class extends SceneObject {
 
 // src/renderer/MineRenderScene.ts
 init_EntityObject();
-var _MineRenderScene = class _MineRenderScene extends import_three32.Scene {
+init_ItemTints();
+var _MineRenderScene = class _MineRenderScene extends import_three33.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -12416,6 +12537,7 @@ var _MineRenderScene = class _MineRenderScene extends import_three32.Scene {
     }
   }
   async addModel(model, options, parent = this) {
+    options = { ...options, tints: await ItemTints.get(model, options?.tints) };
     return this.addSceneObject(model, () => new ModelObject(model, options), options, parent);
   }
   async addBlock(blockState, options, parent = this) {
@@ -12451,7 +12573,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three34 = require("three");
+var import_three35 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -12460,11 +12582,11 @@ init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three33 = require("three");
+var import_three34 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three33.EventDispatcher {
+var OrbitControls = class extends import_three34.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -12473,7 +12595,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three33.Vector3();
+    this.target = new import_three34.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -12495,8 +12617,8 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three33.MOUSE.ROTATE, MIDDLE: import_three33.MOUSE.DOLLY, RIGHT: import_three33.MOUSE.PAN };
-    this.touches = { ONE: import_three33.TOUCH.ROTATE, TWO: import_three33.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three34.MOUSE.ROTATE, MIDDLE: import_three34.MOUSE.DOLLY, RIGHT: import_three34.MOUSE.PAN };
+    this.touches = { ONE: import_three34.TOUCH.ROTATE, TWO: import_three34.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -12525,11 +12647,11 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three33.Vector3();
-      const quat = new import_three33.Quaternion().setFromUnitVectors(object.up, new import_three33.Vector3(0, 1, 0));
+      const offset = new import_three34.Vector3();
+      const quat = new import_three34.Quaternion().setFromUnitVectors(object.up, new import_three34.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three33.Vector3();
-      const lastQuaternion = new import_three33.Quaternion();
+      const lastPosition = new import_three34.Vector3();
+      const lastQuaternion = new import_three34.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -12615,20 +12737,20 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three33.Spherical();
-    const sphericalDelta = new import_three33.Spherical();
+    const spherical = new import_three34.Spherical();
+    const sphericalDelta = new import_three34.Spherical();
     let scale = 1;
-    const panOffset = new import_three33.Vector3();
+    const panOffset = new import_three34.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three33.Vector2();
-    const rotateEnd = new import_three33.Vector2();
-    const rotateDelta = new import_three33.Vector2();
-    const panStart = new import_three33.Vector2();
-    const panEnd = new import_three33.Vector2();
-    const panDelta = new import_three33.Vector2();
-    const dollyStart = new import_three33.Vector2();
-    const dollyEnd = new import_three33.Vector2();
-    const dollyDelta = new import_three33.Vector2();
+    const rotateStart = new import_three34.Vector2();
+    const rotateEnd = new import_three34.Vector2();
+    const rotateDelta = new import_three34.Vector2();
+    const panStart = new import_three34.Vector2();
+    const panEnd = new import_three34.Vector2();
+    const panDelta = new import_three34.Vector2();
+    const dollyStart = new import_three34.Vector2();
+    const dollyEnd = new import_three34.Vector2();
+    const dollyDelta = new import_three34.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -12644,7 +12766,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three33.Vector3();
+      const v = new import_three34.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -12652,7 +12774,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three33.Vector3();
+      const v = new import_three34.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12665,7 +12787,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three33.Vector3();
+      const offset = new import_three34.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -12914,12 +13036,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three33.MOUSE.DOLLY:
+        case import_three34.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three33.MOUSE.ROTATE:
+        case import_three34.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -12930,7 +13052,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three33.MOUSE.PAN:
+        case import_three34.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -12986,12 +13108,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three33.TOUCH.ROTATE:
+            case import_three34.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three33.TOUCH.PAN:
+            case import_three34.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -13002,12 +13124,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three33.TOUCH.DOLLY_PAN:
+            case import_three34.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three33.TOUCH.DOLLY_ROTATE:
+            case import_three34.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -13074,7 +13196,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three33.Vector2();
+        position = new import_three34.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -13094,10 +13216,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three33.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three33.MOUSE.ROTATE;
-    this.touches.ONE = import_three33.TOUCH.PAN;
-    this.touches.TWO = import_three33.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three34.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three34.MOUSE.ROTATE;
+    this.touches.ONE = import_three34.TOUCH.PAN;
+    this.touches.TWO = import_three34.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -13148,14 +13270,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three34.PerspectiveCamera(
+        return new import_three35.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three34.OrthographicCamera(
+        return new import_three35.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -13166,7 +13288,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three34.WebGLRenderer({
+    const renderer = new import_three35.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -13174,8 +13296,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three34.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three34.SRGBColorSpace;
+    renderer.shadowMap.type = import_three35.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three35.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -13210,20 +13332,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three34.GridHelper(128, 16);
+      const gridHelper = new import_three35.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three34.GridHelper(128, 16);
+      const gridHelper2 = new import_three35.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three34.GridHelper(128, 16);
+      const gridHelper3 = new import_three35.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three34.AxesHelper(64);
+      const axesHelper = new import_three35.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -13482,8 +13604,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three34.Vector3(50, 50, 50),
-    lookingAt: new import_three34.Vector3(0, 0, 0)
+    position: new import_three35.Vector3(50, 50, 50),
+    lookingAt: new import_three35.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -13679,6 +13801,7 @@ var Skins = class {
 };
 
 // src/texture/index.ts
+init_Colormaps();
 init_TextureAtlas();
 init_TextureLoader();
 init_Textures();
@@ -13947,12 +14070,12 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three39 = require("three");
+var import_three40 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three37 = require("three");
+var import_three38 = require("three");
 init_Model();
 init_BatchedExecutor();
 init_AssetKey();
@@ -13960,7 +14083,7 @@ init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three36 = require("three");
+var import_three37 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -14026,12 +14149,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three36.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three37.Matrix4().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new import_three36.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three37.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -14061,20 +14184,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three38.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three38.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -14095,7 +14218,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 import_three37.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three38.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -14173,13 +14296,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three38.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three38.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -14201,7 +14324,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three38.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -14213,7 +14336,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three38.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14247,14 +14370,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three37.Vector3(
+    return new import_three38.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three37.Vector3(
+    return new import_three38.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14277,10 +14400,10 @@ var MineRenderWorld = class {
 init_Model();
 
 // src/world/SectionMesh.ts
-var import_three38 = require("three");
+var import_three39 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three38.Group {
+var SectionMesh = class _SectionMesh extends import_three39.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -14353,18 +14476,18 @@ var SectionMesh = class _SectionMesh extends import_three38.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three38.BufferGeometry();
-      geometry.setAttribute("position", new import_three38.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three38.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three38.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three38.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three39.BufferGeometry();
+      geometry.setAttribute("position", new import_three39.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three39.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three39.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three39.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three38.Mesh(geometry, material);
+      const mesh = new import_three39.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -14398,10 +14521,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three39.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three40.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three40.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -14409,10 +14532,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three39.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three40.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three40.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -14498,7 +14621,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three39.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three40.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -14522,14 +14645,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three39.Vector3(
+    return new import_three40.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three39.Vector3(
+    return new import_three40.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z