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

package/dist/node/index.mjs

@@ -1500,7 +1500,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 };
@@ -1509,7 +1509,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;
       }
@@ -1520,7 +1520,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;
@@ -3322,11 +3322,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;
       }
@@ -3376,7 +3376,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);
@@ -3415,6 +3415,7 @@ var init_EntityAnimation = __esm({
 });
 
 // src/entity/scene/EntityAnimationPlayer.ts
+import { Euler as Euler3, Vector3 as Vector35 } from "three";
 var ZERO, EntityAnimationPlayer;
 var init_EntityAnimationPlayer = __esm({
   "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -3434,25 +3435,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 Vector35(...pose.offset) : object.position.clone(),
+              baseRotation: pose ? new Euler3(...pose.rotation, "ZYX") : object.rotation.clone(),
+              baseScale: pose ? new Vector35(...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) {
@@ -3481,10 +3502,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]);
         }
       }
     };
@@ -3551,7 +3572,7 @@ var init_InstanceReference = __esm({
 });
 
 // src/renderer/SceneObject.ts
-import { Color as Color2, Euler as Euler3, InstancedBufferAttribute, InstancedMesh, MathUtils, Matrix4 as Matrix44, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector35 } from "three";
+import { Color as Color2, Euler as Euler4, InstancedBufferAttribute, InstancedMesh, MathUtils, Matrix4 as Matrix44, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion3, Vector3 as Vector36 } from "three";
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
@@ -3826,9 +3847,9 @@ var init_SceneObject = __esm({
       }
       setPositionRotationScaleAt(index, position, rotation, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-        const oldPosition = new Vector35();
+        const oldPosition = new Vector36();
         const oldRotation = new Quaternion3();
-        const oldScale = new Vector35();
+        const oldScale = new Vector36();
         const matrix = new Matrix44();
         if (!scale || !rotation || !position) {
           this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
@@ -3844,7 +3865,7 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, position);
       }
-      getPositionAt(index, vector = new Vector35()) {
+      getPositionAt(index, vector = new Vector36()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixPosition(matrix);
@@ -3854,17 +3875,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 Euler3()) {
+      getRotationAt(index, euler = new Euler4()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const rotation = new Quaternion3();
-        this.getMatrixAt(index).decompose(new Vector35(), rotation, new Vector35());
+        this.getMatrixAt(index).decompose(new Vector36(), rotation, new Vector36());
         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 Vector35()) {
+      getScaleAt(index, vector = new Vector36()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixScale(matrix);
@@ -3989,7 +4010,7 @@ var init_SceneObject = __esm({
 });
 
 // src/entity/scene/EntityObject.ts
-import { Color as Color3, Euler as Euler4, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
+import { Color as Color3, Euler as Euler5, Matrix4 as Matrix45, Object3D as Object3D3 } from "three";
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -4019,7 +4040,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());
@@ -4039,7 +4061,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() {
@@ -4071,36 +4094,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) {
@@ -4139,7 +4187,7 @@ var init_EntityObject = __esm({
             const matrix = new Matrix45();
             if ("scale" in op) matrix.makeScale(...op.scale);
             else if ("translate" in op) matrix.makeTranslation(...op.translate);
-            else matrix.makeRotationFromEuler(new Euler4(...op.rotate, "ZYX"));
+            else matrix.makeRotationFromEuler(new Euler5(...op.rotate, "ZYX"));
             modelRoot.matrix.multiply(matrix);
           }
           modelRoot.matrixAutoUpdate = false;
@@ -4160,6 +4208,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) {
@@ -4234,7 +4283,7 @@ import {
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector39
+  Vector3 as Vector310
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -4553,15 +4602,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector39();
-  const _vB = new Vector39();
-  const _vC = new Vector39();
-  const _tempA = new Vector39();
-  const _tempB = new Vector39();
-  const _tempC = new Vector39();
-  const _morphA = new Vector39();
-  const _morphB = new Vector39();
-  const _morphC = new Vector39();
+  const _vA = new Vector310();
+  const _vB = new Vector310();
+  const _vC = new Vector310();
+  const _tempA = new Vector310();
+  const _tempB = new Vector310();
+  const _tempC = new Vector310();
+  const _morphA = new Vector310();
+  const _morphB = new Vector310();
+  const _morphC = new Vector310();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4771,7 +4820,7 @@ var init_BufferGeometryUtils = __esm({
 });
 
 // src/model/ModelCulling.ts
-import { Vector3 as Vector310 } from "three";
+import { Vector3 as Vector311 } from "three";
 var ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
@@ -4780,7 +4829,7 @@ var init_ModelCulling = __esm({
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new Vector310(...offset).applyEuler(rotation);
+          const normal = new Vector311(...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;
@@ -4925,8 +4974,89 @@ 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
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler6, Matrix4 as Matrix49 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler7, Matrix4 as Matrix49 } from "three";
 function isModelObject(obj) {
   return obj.isModelObject;
 }
@@ -4947,6 +5077,7 @@ var init_ModelObject = __esm({
     init_SpecialItems();
     init_EntityObject();
     init_GuiLight();
+    init_ItemTints();
     p7 = prefix("ModelObject");
     ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
@@ -4965,6 +5096,7 @@ var init_ModelObject = __esm({
         this.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
       }
       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);
@@ -5031,7 +5163,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler6(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler7(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -5652,7 +5784,7 @@ import {
   Color as Color4,
   Matrix3,
   Vector2 as Vector22,
-  Vector3 as Vector36
+  Vector3 as Vector37
 } from "three";
 var OBJExporter = class {
   parse(object) {
@@ -5660,9 +5792,9 @@ var OBJExporter = class {
     let indexVertex = 0;
     let indexVertexUvs = 0;
     let indexNormals = 0;
-    const vertex = new Vector36();
+    const vertex = new Vector37();
     const color = new Color4();
-    const normal = new Vector36();
+    const normal = new Vector37();
     const uv = new Vector22();
     const face = [];
     function parseMesh(mesh) {
@@ -5791,7 +5923,7 @@ var OBJExporter = class {
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
 import {
   Matrix3 as Matrix32,
-  Vector3 as Vector37,
+  Vector3 as Vector38,
   Color as Color5
 } from "three";
 var PLYExporter = class {
@@ -5884,7 +6016,7 @@ property list uchar int vertex_index
 `;
     }
     header += "end_header\n";
-    const vertex = new Vector37();
+    const vertex = new Vector38();
     const normalMatrixWorld = new Matrix32();
     let result = null;
     if (options.binary === true) {
@@ -6083,7 +6215,7 @@ import {
   Source,
   SRGBColorSpace as SRGBColorSpace4,
   CompressedTexture,
-  Vector3 as Vector38,
+  Vector3 as Vector39,
   Quaternion as Quaternion4
 } from "three";
 
@@ -6544,7 +6676,7 @@ var GLTFWriter = class {
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new Vector38();
+    const v = new Vector39();
     for (let i = 0, il = normal.count; i < il; i++) {
       if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
     }
@@ -6561,7 +6693,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 Vector38();
+    const v = new Vector39();
     for (let i = 0, il = attribute.count; i < il; i++) {
       v.fromBufferAttribute(attribute, i);
       if (v.x === 0 && v.y === 0 && v.z === 0) {
@@ -7828,9 +7960,9 @@ var GLTFMeshGpuInstancing = class {
     const rotationAttr = new Float32Array(mesh.count * 4);
     const scaleAttr = new Float32Array(mesh.count * 3);
     const matrix = new Matrix46();
-    const position = new Vector38();
+    const position = new Vector39();
     const quaternion = new Quaternion4();
-    const scale = new Vector38();
+    const scale = new Vector39();
     for (let i = 0; i < mesh.count; i++) {
       mesh.getMatrixAt(i, matrix);
       matrix.decompose(position, quaternion, scale);
@@ -8812,6 +8944,7 @@ function isInstanceable(obj) {
 init_DisplayPosition();
 init_DisplayTransforms();
 init_GuiLight();
+init_ItemTints();
 init_Model();
 init_ModelCulling();
 init_ModelGenerator();
@@ -8822,7 +8955,7 @@ init_SpecialItems();
 init_BlockStates();
 init_MineRenderError();
 init_util();
-import { Euler as Euler7 } from "three";
+import { Euler as Euler8 } from "three";
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
     if (Array.isArray(value)) {
@@ -8897,7 +9030,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new Euler7();
+    const rotation = new Euler8();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -8909,10 +9042,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 = {
@@ -8967,7 +9097,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;
@@ -8985,18 +9115,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
@@ -9007,7 +9125,7 @@ var import_ts_deepmerge6 = __toESM(require_dist());
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
-import { Euler as Euler8, Matrix4 as Matrix411, Quaternion as Quaternion5, Vector3 as Vector311 } from "three";
+import { Euler as Euler9, Matrix4 as Matrix411, Quaternion as Quaternion5, Vector3 as Vector312 } from "three";
 init_ModelCulling();
 init_FluidGeometry();
 init_Entities();
@@ -9130,12 +9248,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 Vector311();
+    const position = new Vector312();
     const rotation = new Quaternion5();
-    const scale = new Vector311();
+    const scale = new Vector312();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector311(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new Euler8().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector312(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new Euler9().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -12252,6 +12370,7 @@ var SkinObject = class extends SceneObject {
 
 // src/renderer/MineRenderScene.ts
 init_EntityObject();
+init_ItemTints();
 var MineRenderScene = class _MineRenderScene extends Scene5 {
   constructor(options) {
     super();
@@ -12347,6 +12466,7 @@ var MineRenderScene = class _MineRenderScene extends Scene5 {
     }
   }
   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) {
@@ -12380,7 +12500,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector313, WebGLRenderer as WebGLRenderer2 } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera as PerspectiveCamera2, SRGBColorSpace as SRGBColorSpace6, Vector3 as Vector314, WebGLRenderer as WebGLRenderer2 } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
 init_Model();
@@ -12396,7 +12516,7 @@ import {
   Spherical,
   TOUCH,
   Vector2 as Vector25,
-  Vector3 as Vector312
+  Vector3 as Vector313
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -12410,7 +12530,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector312();
+    this.target = new Vector313();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -12462,10 +12582,10 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector312();
-      const quat = new Quaternion6().setFromUnitVectors(object.up, new Vector312(0, 1, 0));
+      const offset = new Vector313();
+      const quat = new Quaternion6().setFromUnitVectors(object.up, new Vector313(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector312();
+      const lastPosition = new Vector313();
       const lastQuaternion = new Quaternion6();
       const twoPI = 2 * Math.PI;
       return function update() {
@@ -12555,7 +12675,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector312();
+    const panOffset = new Vector313();
     let zoomChanged = false;
     const rotateStart = new Vector25();
     const rotateEnd = new Vector25();
@@ -12581,7 +12701,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector312();
+      const v = new Vector313();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -12589,7 +12709,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector312();
+      const v = new Vector313();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12602,7 +12722,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector312();
+      const offset = new Vector313();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -13093,8 +13213,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new Vector313(50, 50, 50),
-        lookingAt: new Vector313(0, 0, 0)
+        position: new Vector314(50, 50, 50),
+        lookingAt: new Vector314(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -13617,6 +13737,7 @@ var Skins = class {
 };
 
 // src/texture/index.ts
+init_Colormaps();
 init_TextureAtlas();
 init_TextureLoader();
 init_Textures();
@@ -13885,13 +14006,13 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector316 } from "three";
+import { Vector3 as Vector317 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
-import { Vector3 as Vector315 } from "three";
+import { Vector3 as Vector316 } from "three";
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
@@ -13901,7 +14022,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { Matrix4 as Matrix412, Vector3 as Vector314 } from "three";
+import { Matrix4 as Matrix412, Vector3 as Vector315 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -13969,7 +14090,7 @@ var SectionModels = class {
         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 Vector314(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new Vector315(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -13999,20 +14120,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector315(posOrX, y, z));
+      return this.getBlockAt(new Vector316(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector316(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 Vector315(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector315(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -14033,7 +14154,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 Vector315(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector316(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -14111,13 +14232,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 Vector315(...offset));
+        const neighbor = pos.clone().add(new Vector316(...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 Vector315(x, y, z));
+            const neighbor = pos.clone().add(new Vector316(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -14139,7 +14260,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new Vector315(x, y, z));
+                const neighbor = pos.clone().add(new Vector316(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -14151,7 +14272,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new Vector315(...offset));
+              const neighbor = pos.clone().add(new Vector316(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14185,14 +14306,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new Vector315(
+    return new Vector316(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector315(
+    return new Vector316(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14336,10 +14457,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector316(posOrX, y, z));
+      return this.getBlockAt(new Vector317(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -14347,10 +14468,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -14436,7 +14557,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector316(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector317(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -14460,14 +14581,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector316(
+    return new Vector317(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -14501,6 +14622,7 @@ export {
   CanvasImage,
   Chunk,
   ChunkData,
+  Colormaps,
   CubeFace,
   CubeFaceIndex,
   DEFAULT_ELEMENTS,
@@ -14526,6 +14648,7 @@ export {
   ImageLoader,
   InstanceManager,
   InstanceReference,
+  ItemTints,
   MapControls,
   Materials,
   Meshes,