minerender 2.1.0-beta.5 → 2.1.0-beta.6

package/dist/bundle.js

@@ -35632,6 +35632,7 @@ void main() {
             this.entityAnimationCache,
             this.blockEntityIndexCache,
             this.fontCache,
+            this.unihexCache,
             this.bannerPatternCache,
             this.mineRenderDataCache,
             this.usernameUuidCache,
@@ -35685,6 +35686,7 @@ void main() {
       _Caching.entityTextureCache = _Caching.createAssetCache();
       _Caching.entityAnimationCache = _Caching.createAssetCache();
       _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+      _Caching.unihexCache = _Caching.createAssetCache();
       _Caching.fontCache = _Caching.createAssetCache();
       _Caching.bannerPatternCache = _Caching.createAssetCache();
       _Caching.mineRenderDataCache = _Caching.createAssetCache();
@@ -36796,6 +36798,7 @@ void main() {
         static createShadedCanvasMaterial(canvas, transparent = false, shade = false, boundUvs = false) {
           const vertShader = `
             uniform bool SHADE;
+            attribute float shade;
             
             // Keep MSAA edge pixels from sampling outside the face's atlas region.
             #if __VERSION__ >= 300
@@ -36818,7 +36821,7 @@ void main() {
             void main()
             {
 
-                if (SHADE) {
+                if (SHADE && shade > 0.5) {
 
                     #ifdef USE_INSTANCING
                         vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
@@ -36927,7 +36930,7 @@ void main() {
               side: transparent ? DoubleSide : FrontSide,
               alphaTest: 0.5
             });
-            Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+            Object.assign(material.defaultAttributeValues, { shade: [1], uvBounds: [0, 0, 1, 1] });
             return material;
           } catch (e6) {
             console.warn(e6);
@@ -37098,6 +37101,7 @@ void main() {
         AssetParser2["IMAGE"] = "image";
         AssetParser2["LIST"] = "list";
         AssetParser2["JSON"] = "json";
+        AssetParser2["BINARY"] = "binary";
         return AssetParser2;
       })(AssetParser || {});
     }
@@ -38432,13 +38436,13 @@ ${key}` : key, async () => {
         break;
     }
     if (rotation.rescale) {
-      if (Math.abs(rotation.angle) === 22.5) {
-        const s4 = 1 / Math.cos(0.39269909262657166);
-        geometry.scale(s4, 1, s4);
-      } else {
-        const s4 = 1 / Math.cos(0.7853981852531433);
-        geometry.scale(s4, 1, s4);
-      }
+      const angle = toRadians(rotation.angle);
+      const s4 = 1 / Math.max(Math.abs(Math.cos(angle)), Math.abs(Math.sin(angle)));
+      geometry.scale(
+        rotation.axis === "x" /* X */ ? 1 : s4,
+        rotation.axis === "y" /* Y */ ? 1 : s4,
+        rotation.axis === "z" /* Z */ ? 1 : s4
+      );
     }
     geometry.translate(origin.x, origin.y, origin.z);
   }
@@ -73063,7 +73067,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // src/assets/source/HostedAssetSource.ts
-  var p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
+  var BINARY_TIMEOUT, p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
   var init_HostedAssetSource = __esm({
     "src/assets/source/HostedAssetSource.ts"() {
       init_dirname();
@@ -73079,6 +73083,7 @@ return ${compiler2.callType("value", tagType)}
       init_AssetLoader();
       init_parser();
       init_merge();
+      BINARY_TIMEOUT = 6e4;
       p7 = prefix("HostedAssetSource");
       DEFAULT_OPTIONS2 = {
         retryDefaults: true
@@ -73219,6 +73224,15 @@ return ${compiler2.callType("value", tagType)}
           return response.data;
         }
       };
+      _HostedAssetSource.BINARY = {
+        config(request) {
+          request.timeout = BINARY_TIMEOUT;
+          request.responseType = "arraybuffer";
+        },
+        parse(response) {
+          return { data: new Uint8Array(response.data) };
+        }
+      };
       _HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
         ["model" /* MODEL */, _HostedAssetSource.MODEL],
         ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
@@ -73226,7 +73240,8 @@ return ${compiler2.callType("value", tagType)}
         ["nbt" /* NBT */, _HostedAssetSource.NBT],
         ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
         ["list" /* LIST */, _HostedAssetSource.LIST],
-        ["json" /* JSON */, _HostedAssetSource.JSON]
+        ["json" /* JSON */, _HostedAssetSource.JSON],
+        ["binary" /* BINARY */, _HostedAssetSource.BINARY]
       ]);
       HostedAssetSource = _HostedAssetSource;
     }
@@ -81841,7 +81856,7 @@ return ${compiler2.callType("value", tagType)}
   function readUint8Array(reader, offset, size, diskNumber) {
     return reader.readUint8Array(offset, size, diskNumber);
   }
-  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, SplitDataReader, SplitDataWriter;
+  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, TextWriter, Uint8ArrayReader, SplitDataReader, SplitDataWriter;
   var init_io = __esm({
     "../../node_modules/@zip.js/zip.js/lib/core/io.js"() {
       init_dirname();
@@ -81924,6 +81939,46 @@ return ${compiler2.callType("value", tagType)}
           return this.blob;
         }
       };
+      TextWriter = class extends BlobWriter {
+        constructor(encoding) {
+          super(encoding);
+          Object.assign(this, {
+            encoding,
+            utf8: !encoding || encoding.toLowerCase() == "utf-8"
+          });
+        }
+        async getData() {
+          const {
+            encoding,
+            utf8
+          } = this;
+          const blob = await super.getData();
+          if (blob.text && utf8) {
+            return blob.text();
+          } else {
+            const reader = new FileReader();
+            return new Promise((resolve, reject) => {
+              Object.assign(reader, {
+                onload: ({ target }) => resolve(target.result),
+                onerror: () => reject(reader.error)
+              });
+              reader.readAsText(blob, encoding);
+            });
+          }
+        }
+      };
+      Uint8ArrayReader = class extends Reader {
+        constructor(array) {
+          super();
+          Object.assign(this, {
+            array,
+            size: array.length
+          });
+        }
+        readUint8Array(index, length) {
+          return this.array.slice(index, index + length);
+        }
+      };
       SplitDataReader = class extends Reader {
         constructor(readers) {
           super();
@@ -84682,6 +84737,181 @@ ${key}` : key;
     }
   });
 
+  // src/assets/_fonts/Unihex.ts
+  var Unihex_exports = {};
+  __export(Unihex_exports, {
+    loadUnihex: () => loadUnihex
+  });
+  function readHex(text2, filename, glyphs) {
+    const lines = text2.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+    lines.forEach((line, index) => {
+      const match = /^([0-9A-F]{4,6}):([0-9A-F]+)$/.exec(line);
+      if (!match || ![32, 64, 96, 128].includes(match[2].length)) {
+        throw new Error(`Invalid Unihex record in ${filename} at line ${index + 1}`);
+      }
+      const codepoint = parseInt(match[1], 16);
+      if (codepoint > 1114111) throw new Error(`Invalid Unihex codepoint in ${filename} at line ${index + 1}`);
+      const bitWidth = match[2].length / 4;
+      const rowLength = bitWidth / 4;
+      const rows = new Uint32Array(GLYPH_HEIGHT);
+      let mask = 0;
+      for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+        rows[y5] = parseInt(match[2].slice(y5 * rowLength, (y5 + 1) * rowLength), 16);
+        mask |= rows[y5];
+      }
+      let left = 0, right = bitWidth;
+      if (mask) {
+        while (!(mask >>> bitWidth - left - 1 & 1)) left++;
+        right = bitWidth - 1;
+        while (!(mask >>> bitWidth - right - 1 & 1)) right--;
+      }
+      glyphs.set(codepoint, { rows, bitWidth, left, right });
+    });
+  }
+  async function parseUnihex(key) {
+    try {
+      const asset2 = await AssetLoader.get(key, "binary" /* BINARY */);
+      if (!asset2) throw new Error(`Could not load Unihex archive ${key.toNamespacedString()}`);
+      const records = /* @__PURE__ */ new Map();
+      const reader = new ZipReader(new Uint8ArrayReader(asset2.data), { useWebWorkers: false, useCompressionStream: false });
+      try {
+        for (const entry of await reader.getEntries()) {
+          if (!entry.directory && entry.filename.endsWith(".hex")) {
+            readHex(await entry.getData(new TextWriter(), { checkSignature: true }), entry.filename, records);
+          }
+        }
+      } finally {
+        await reader.close();
+      }
+      const indices = new Int32Array(1114112).fill(-1);
+      const rows = new Uint32Array(records.size * GLYPH_HEIGHT), metrics = new Uint8Array(records.size * 3);
+      let index = 0;
+      for (const [codepoint, record] of records) {
+        indices[codepoint] = index;
+        rows.set(record.rows, index * GLYPH_HEIGHT);
+        metrics.set([record.bitWidth, record.left, record.right], index * 3);
+        index++;
+      }
+      return { indices, rows, metrics };
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return void 0;
+    }
+  }
+  async function loadUnihex(provider, fontKey, characters) {
+    const origin = new AssetKey(DEFAULT_NAMESPACE, "", void 0, void 0, "assets", "", fontKey.root);
+    const key = AssetKey.parse("font", provider.hex_file, origin);
+    key.assetType = void 0;
+    const glyphs = /* @__PURE__ */ new Map();
+    let overrides;
+    try {
+      overrides = (provider.size_overrides ?? []).map((override) => {
+        const from = override.from.codePointAt(0), to = override.to.codePointAt(0);
+        if ([...override.from].length !== 1 || [...override.to].length !== 1 || from >= to || !Number.isInteger(override.left) || !Number.isInteger(override.right) || override.right < override.left) {
+          throw new Error(`Invalid Unihex size override in font ${fontKey.toNamespacedString()}`);
+        }
+        return { ...override, from, to };
+      });
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return glyphs;
+    }
+    const file = await Caching.unihexCache.get(key.serialize(), () => parseUnihex(key));
+    if (!file) return glyphs;
+    let atlas = atlases.get(provider);
+    if (!atlas) {
+      atlas = new UnihexAtlas();
+      atlases.set(provider, atlas);
+    }
+    for (const character of characters) {
+      const codepoint = character.codePointAt(0), index = file.indices[codepoint];
+      if (index < 0) continue;
+      const record = {
+        rows: file.rows.subarray(index * GLYPH_HEIGHT, (index + 1) * GLYPH_HEIGHT),
+        bitWidth: file.metrics[index * 3],
+        left: file.metrics[index * 3 + 1],
+        right: file.metrics[index * 3 + 2]
+      };
+      const override = overrides.find((range) => codepoint >= range.from && codepoint <= range.to);
+      if (override) {
+        record.left = override.left;
+        record.right = override.right;
+      }
+      const width = record.right - record.left + 1;
+      let rendered;
+      const render = () => rendered ?? (rendered = atlas.draw(record));
+      glyphs.set(character, {
+        get image() {
+          return render().image;
+        },
+        get x() {
+          return render().x;
+        },
+        get y() {
+          return render().y;
+        },
+        width,
+        height: GLYPH_HEIGHT,
+        scale: 0.5,
+        ascent: 7,
+        advance: Math.floor(width / 2) + 1,
+        boldOffset: 0.5,
+        shadowOffset: 0.5
+      });
+    }
+    return glyphs;
+  }
+  var ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+  var init_Unihex = __esm({
+    "src/assets/_fonts/Unihex.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_zip();
+      init_AssetKey();
+      init_AssetLoader();
+      init_Assets();
+      init_Caching();
+      init_AssetParsers();
+      init_CanvasCompat();
+      ATLAS_SIZE = 512;
+      GLYPH_HEIGHT = 16;
+      UnihexAtlas = class {
+        constructor() {
+          this.x = 0;
+          this.y = 0;
+        }
+        draw(glyph) {
+          const width = glyph.right - glyph.left + 1;
+          if (this.image && this.x + width > this.image.width) {
+            this.x = 0;
+            this.y += GLYPH_HEIGHT;
+          }
+          if (!this.image || this.y + GLYPH_HEIGHT > this.image.height || width > this.image.width) {
+            this.image = createCanvas(Math.max(ATLAS_SIZE, width), ATLAS_SIZE);
+            this.x = 0;
+            this.y = 0;
+          }
+          const context = this.image.getContext("2d");
+          const pixels = context.createImageData(width, GLYPH_HEIGHT);
+          for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+            for (let x4 = 0; x4 < width; x4++) {
+              const column = glyph.left + x4;
+              if (column < 0 || column >= glyph.bitWidth || !(glyph.rows[y5] >>> glyph.bitWidth - column - 1 & 1)) continue;
+              pixels.data.fill(255, (y5 * width + x4) * 4, (y5 * width + x4 + 1) * 4);
+            }
+          }
+          const result = { image: this.image, x: this.x, y: this.y };
+          context.putImageData(pixels, this.x, this.y);
+          this.x += width;
+          return result;
+        }
+      };
+      atlases = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
   // src/assets/Fonts.ts
   var Fonts;
   var init_Fonts = __esm({
@@ -84695,7 +84925,7 @@ ${key}` : key;
       init_ModelTextures();
       init_Caching();
       Fonts = class {
-        /** Combines font definitions in source-priority order. Unsupported Unihex and TrueType providers are skipped. */
+        /** Combines font definitions in source-priority order. TrueType providers are skipped. */
         static async get(key = "minecraft:default") {
           const fontKey = typeof key === "string" ? AssetKey.parse("font", key) : key;
           return await Caching.fontCache.get(fontKey.serialize(), () => this.load(fontKey, []));
@@ -84711,6 +84941,7 @@ ${key}` : key;
           const stack = await AssetLoader.getAll(key, "json" /* JSON */);
           if (stack.length === 0) throw new Error(`Could not load font ${key.toNamespacedString()}`);
           const glyphs = /* @__PURE__ */ new Map();
+          const providers = [];
           for (const asset2 of stack) {
             for (const provider of asset2.providers) {
               if (provider.filter?.uniform || provider.filter?.jp) continue;
@@ -84729,17 +84960,43 @@ ${key}` : key;
                   break;
                 case "reference":
                 case "minecraft:reference":
-                  provided = (await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized])).glyphs;
+                  const reference = await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized]);
+                  if (reference.resolve) {
+                    providers.push(async (characters) => {
+                      await reference.resolve(characters);
+                      return reference.glyphs;
+                    });
+                    continue;
+                  }
+                  provided = reference.glyphs;
                   break;
+                case "unihex":
+                case "minecraft:unihex":
+                  providers.push(async (characters) => (await Promise.resolve().then(() => (init_Unihex(), Unihex_exports))).loadUnihex(provider, key, characters));
+                  continue;
                 default:
                   continue;
               }
-              for (const [character, glyph] of provided) {
+              if (providers.every((provider2) => provider2 instanceof Map)) for (const [character, glyph] of provided) {
                 if (character !== "\0" && !glyphs.has(character)) glyphs.set(character, glyph);
               }
+              providers.push(provided);
             }
           }
-          return { glyphs };
+          return { glyphs, resolve: providers.every((provider) => provider instanceof Map) ? void 0 : async (characters) => {
+            const remaining = new Set([...characters].filter((character) => character !== "\0" && character !== "\n" && character !== "\r" && !glyphs.has(character)));
+            for (const provider of providers) {
+              if (!remaining.size) break;
+              const provided = provider instanceof Map ? provider : await provider([...remaining].join(""));
+              for (const character of remaining) {
+                const glyph = provided.get(character);
+                if (glyph) {
+                  glyphs.set(character, glyph);
+                  remaining.delete(character);
+                }
+              }
+            }
+          } };
         }
         static async bitmap(provider, fontKey) {
           const rows = provider.chars.map((row) => [...row]);
@@ -84835,6 +85092,13 @@ ${key}` : key;
   });
 
   // src/entity/scene/EntityAnimationPlayer.ts
+  function validateAnimationWeights(weights, count) {
+    const values = Array.from(weights);
+    if (values.length !== count || values.some((weight) => !Number.isFinite(weight) || weight < 0)) {
+      throw new Error("Animation weights must match the clip count and contain only finite nonnegative numbers");
+    }
+    return values;
+  }
   var ZERO, EntityAnimationPlayer;
   var init_EntityAnimationPlayer = __esm({
     "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -84847,12 +85111,20 @@ ${key}` : key;
       EntityAnimationPlayer = class {
         constructor() {
           this.parts = [];
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
-          this.loop = false;
           this.speed = 1;
         }
         get animation() {
-          return this._animation;
+          return this._animations[0];
+        }
+        get animations() {
+          return this._animations.slice();
+        }
+        get weights() {
+          return this._weights.slice();
         }
         get time() {
           return this._time;
@@ -84862,10 +85134,20 @@ ${key}` : key;
          * without them, the current pose is used. Stopping restores the pose from before playback.
          */
         play(layers, animation, options = {}, poses) {
+          this.playAnimations(layers, [animation], options, poses);
+        }
+        /**
+         * Starts clips on matching parts with a shared clock. Weighted offsets add to the supplied baked poses
+         * or, without poses, to each animated part's pose when playback starts.
+         */
+        playAnimations(layers, animations, options = {}, poses) {
+          const weights = validateAnimationWeights(options.weights ?? animations.map(() => 1), animations.length);
           this.stop();
-          this._animation = animation;
+          this._animations = animations.slice();
+          this._weights = weights;
+          if (!animations.length) return;
           this._time = options.time ?? 0;
-          this.loop = options.loop ?? animation.loop;
+          this.loops = animations.map((animation) => options.loop ?? animation.loop);
           this.speed = options.speed ?? 1;
           for (const layer of layers) {
             const objects = [];
@@ -84874,7 +85156,8 @@ ${key}` : key;
                 if (poses.has(object4)) objects.push(object4);
               });
             } else {
-              for (const bone of Object.keys(animation.bones)) {
+              const bones = new Set(animations.flatMap((animation) => Object.keys(animation.bones)));
+              for (const bone of bones) {
                 const object4 = layer.getObjectByName(`group:${bone}`);
                 if (object4) objects.push(object4);
               }
@@ -84898,7 +85181,7 @@ ${key}` : key;
         }
         /** Restores the poses from before playback. Returns whether an animation was active. */
         stop() {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           for (const part of this.parts) {
             part.object.position.copy(part.position);
             part.object.rotation.copy(part.rotation);
@@ -84910,12 +85193,14 @@ ${key}` : key;
         /** Forgets the animation without touching the parts, for parts that no longer exist. */
         clear() {
           this.parts = [];
-          this._animation = void 0;
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
         }
         /** Applies the pose at an absolute playback time. Returns `false` when no clip is active. */
         setTime(seconds) {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           this._time = seconds;
           this.apply();
           return true;
@@ -84924,8 +85209,30 @@ ${key}` : key;
         advance(deltaSeconds) {
           return this.setTime(this._time + deltaSeconds * this.speed);
         }
+        /** Changes weights in clip order and reapplies the current time without restarting playback. */
+        setWeights(weights) {
+          if (!this._animations.length) return false;
+          const validated = validateAnimationWeights(weights, this._animations.length);
+          this._weights = validated;
+          this.apply();
+          return true;
+        }
         apply() {
-          const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+          const pose = /* @__PURE__ */ Object.create(null);
+          for (let i4 = 0; i4 < this._animations.length; i4++) {
+            const weight = this._weights[i4];
+            if (weight === 0) continue;
+            const sampled = sampleEntityAnimation(this._animations[i4], this._time, this.loops[i4]);
+            for (const [bone, channels] of Object.entries(sampled)) {
+              const blended = pose[bone] ?? (pose[bone] = {});
+              for (const channel of ENTITY_ANIMATION_CHANNELS) {
+                const value = channels[channel];
+                if (!value) continue;
+                const target = blended[channel] ?? (blended[channel] = [0, 0, 0]);
+                for (let axis = 0; axis < 3; axis++) target[axis] += value[axis] * weight;
+              }
+            }
+          }
           for (const part of this.parts) {
             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]);
@@ -85554,7 +85861,7 @@ ${key}` : key;
           for (const geometry of this.geometries) geometry.dispose();
           this.geometries.clear();
           for (const dispose of this.disposeWireframes.splice(0)) dispose();
-          for (const player of this.animationPlayers.splice(0)) player.clear();
+          for (const { player } of this.animationPlayers.splice(0)) player.clear();
           this.partPoses.clear();
           super.disposeAndRemoveAllChildren();
         }
@@ -85589,15 +85896,31 @@ ${key}` : key;
         //<editor-fold desc="ANIMATION">
         /** The first active clip, until playback is stopped or the object is disposed. */
         get animation() {
-          return this.animationPlayers[0]?.animation;
+          return this.animationPlayers[0]?.player.animation;
         }
-        /** Clips playing together, each targeting a separate geometry layer. */
+        /** Clips playing together, in the order passed to {@link playAnimations}. */
         get activeAnimations() {
-          return this.animationPlayers.map((player) => player.animation);
+          const animations = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.animations.forEach((animation, i4) => {
+              animations[indices[i4]] = animation;
+            });
+          }
+          return animations;
+        }
+        /** Weights of the active clips, in the same order as {@link activeAnimations}. */
+        get animationWeights() {
+          const weights = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.weights.forEach((weight, i4) => {
+              weights[indices[i4]] = weight;
+            });
+          }
+          return weights;
         }
         /** Seconds since the animation started, before looping. */
         get animationTime() {
-          return this.animationPlayers[0]?.time ?? 0;
+          return this.animationPlayers[0]?.player.time ?? 0;
         }
         /**
          * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
@@ -85608,42 +85931,59 @@ ${key}` : key;
         playAnimation(animation, options) {
           this.playAnimations([animation], options);
         }
-        /** Plays clips with a shared clock and no blending. Selected layers without their own clip follow `main`. */
+        /**
+         * Plays clips with a shared clock, adding their weighted offsets within each geometry layer.
+         * Weights default to 1 and are not normalized. Selected layers without their own clip follow `main`.
+         */
         playAnimations(animations, options) {
-          const targets = /* @__PURE__ */ new Set();
-          const selections = animations.map((animation) => {
+          const weights = validateAnimationWeights(options?.weights ?? animations.map(() => 1), animations.length);
+          const selections = /* @__PURE__ */ new Map();
+          animations.forEach((animation, index) => {
             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((name2) => name2.split("#")[0] === layer);
             if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
-            return { animation, names };
+            let selection = selections.get(layer);
+            if (!selection) selections.set(layer, selection = { animations: [], names, indices: [] });
+            selection.animations.push(animation);
+            selection.indices.push(index);
           });
-          const main = selections.find(({ animation }) => (animation.layer ?? "main") === "main");
-          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !targets.has(name2.split("#")[0])));
+          const main = selections.get("main");
+          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !selections.has(name2.split("#")[0])));
           this.createMeshes();
           this.stopAnimation();
-          for (const { animation, names } of selections) {
+          for (const { animations: clips, names, indices } of selections.values()) {
             const player = new EntityAnimationPlayer();
-            player.play(names.map((name2) => this.getLayerGroup(name2)), animation, options, this.partPoses);
-            this.animationPlayers.push(player);
+            player.playAnimations(
+              names.map((name2) => this.getLayerGroup(name2)),
+              clips,
+              { ...options, weights: indices.map((index) => weights[index]) },
+              this.partPoses
+            );
+            this.animationPlayers.push({ player, indices });
           }
           this.notifyDirty();
         }
+        /** Changes weights in active clip order, notifying the scene without restarting the shared clock. Has no effect without an animation. */
+        setAnimationWeights(weights) {
+          if (!this.animationPlayers.length) return;
+          const values = validateAnimationWeights(weights, this.activeAnimations.length);
+          for (const { player, indices } of this.animationPlayers) player.setWeights(indices.map((index) => values[index]));
+          this.notifyDirty();
+        }
         /** Stops all clips and restores the poses from before playback. */
         stopAnimation() {
           const players = this.animationPlayers.splice(0);
-          for (const player of players) player.stop();
+          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) {
-          for (const player of this.animationPlayers) player.setTime(seconds);
+          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) {
-          for (const player of this.animationPlayers) player.advance(deltaSeconds);
+          for (const { player } of this.animationPlayers) player.advance(deltaSeconds);
           if (this.animationPlayers.length) this.notifyDirty();
         }
         //</editor-fold>
@@ -87881,6 +88221,7 @@ ${key}` : key;
     }
     const font = await Fonts.get(options.font);
     const runs = typeof text2 === "string" ? [{ text: text2 }] : text2;
+    await font.resolve?.(runs.map((run) => run.text).join(""));
     const glyphs = [], lineWidths = [];
     let line = [], width = 0;
     let trailingNewline = false;
@@ -87907,7 +88248,7 @@ ${key}` : key;
           continue;
         }
         const glyph = font.glyphs.get(character);
-        const advance = (glyph?.advance ?? 6) + (style.bold ? 1 : 0);
+        const advance = (glyph?.advance ?? 6) + (style.bold ? glyph?.boldOffset ?? 1 : 0);
         line.push({ character, glyph, advance, style, x: 0, y: 0 });
         width += advance;
         while (width > maxWidth && line.length > 1) {
@@ -87935,7 +88276,7 @@ ${key}` : key;
           batches.push(batch);
         }
         const color3 = new Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
-        const offset = isShadow ? 1 : 0;
+        const offset = isShadow ? glyph?.shadowOffset ?? 1 : 0;
         const top = glyph ? 7 - glyph.ascent : 0;
         const height = glyph ? glyph.height * glyph.scale : 8;
         const width = glyph ? glyph.width * glyph.scale : 5;
@@ -87965,7 +88306,7 @@ ${key}` : key;
           for (let i4 = 0; i4 < 4; i4++) batch.colors.push(color3.r, color3.g, color3.b);
           batch.indices.push(base, base + 2, base + 1, base + 2, base + 3, base + 1);
         };
-        for (const boldOffset of style.bold ? [0, 1] : [0]) {
+        for (const boldOffset of style.bold ? [0, glyph?.boldOffset ?? 1] : [0]) {
           if (glyph) quad(0, top, width, top + height, boldOffset);
           else {
             quad(0, 0, 5, 1, boldOffset);
@@ -92503,6 +92844,10 @@ ${shader.fragmentShader}`.replace(
               this.atlas.model.elements?.forEach((el) => {
                 const elGeo = this._getBoxGeometryFromElement(el).clone();
                 this.geometries.add(elGeo);
+                elGeo.setAttribute("shade", new BufferAttribute(
+                  new Float32Array(elGeo.getAttribute("position").count).fill(!this.originalModel.itemId && el.shade === false ? 0 : 1),
+                  1
+                ));
                 if (this.options.cullMask) {
                   const indices = Array.from(elGeo.getIndex().array);
                   elGeo.setIndex(indices.filter((_4, index) => {
@@ -94105,6 +94450,7 @@ ${shader.fragmentShader}`.replace(
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
     trimCanvas: () => trimCanvas,
+    validateAnimationWeights: () => validateAnimationWeights,
     yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();
@@ -102794,9 +103140,9 @@ gl_FragDepth=readDepth(vUv);
   function compactQuads(geometry, keep) {
     const quads = keep.flatMap((kept, index) => kept ? [index] : []);
     const compact = new BufferGeometry();
-    for (const [name2, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3 })) {
+    for (const [name2, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3, shade: 1 })) {
       const source2 = geometry.getAttribute(name2);
-      const defaults = name2 === "uvBounds" ? [0, 0, 1, 1] : name2 === "color" ? [1, 1, 1] : void 0;
+      const defaults = name2 === "uvBounds" ? [0, 0, 1, 1] : name2 === "color" ? [1, 1, 1] : name2 === "shade" ? [1] : void 0;
       const values = new Float32Array(quads.length * 4 * size);
       for (let q3 = 0; q3 < quads.length; q3++) {
         for (let vertex2 = 0; vertex2 < 4; vertex2++) {
@@ -104074,7 +104420,7 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/SectionGeometry.ts
   function buildSectionGeometry(input) {
-    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
+    const { count, indices, templates, cullMasks, templateData, atlases: atlases2, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
     if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
     if (biomeTints && biomeTints.length !== count * 3) throw new RangeError("Section biome tints must contain RGB for each placement");
@@ -104092,7 +104438,7 @@ gl_FragDepth=readDepth(vUv);
     const cornerBrightness2 = ambientOcclusion ? new Float32Array(4) : void 0;
     for (const template of templateData) {
       const { quads } = template;
-      if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads || template.biomeTint && template.biomeTint.length !== quads) {
+      if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads || template.shade && template.shade.length !== quads * 4 || template.biomeTint && template.biomeTint.length !== quads) {
         throw new RangeError("Section template arrays do not match its quad count");
       }
     }
@@ -104109,8 +104455,8 @@ gl_FragDepth=readDepth(vUv);
     const locations = /* @__PURE__ */ new Map();
     for (const [layer, layerAtlases] of [...visibleAtlases].sort(([a4], [b4]) => a4 - b4)) {
       const firstPage = pages.length;
-      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases[a4].animated) - Number(atlases[b4].animated) || (atlases[a4].animated ? a4 - b4 : atlases[b4].height - atlases[a4].height))) {
-        const { width, height, animated } = atlases[atlas];
+      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases2[a4].animated) - Number(atlases2[b4].animated) || (atlases2[a4].animated ? a4 - b4 : atlases2[b4].height - atlases2[a4].height))) {
+        const { width, height, animated } = atlases2[atlas];
         if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
         let selected = -1;
         for (let i4 = firstPage; !animated && i4 < pages.length; i4++) {
@@ -104153,7 +104499,7 @@ gl_FragDepth=readDepth(vUv);
         });
         if (!quads.sprites.length) continue;
         if (!fluidPages.has(fluid)) {
-          const { width, height } = atlases[data.atlas];
+          const { width, height } = atlases2[data.atlas];
           if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
           fluidPages.set(fluid, {
             layer: 2,
@@ -104171,7 +104517,7 @@ gl_FragDepth=readDepth(vUv);
         const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
         fluidPages.get(fluid).fluids.push({ quads, x: x4, y: y5, z: z4, data, tint });
       }
-      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases[a4.placements[0].atlas].animated) - Number(atlases[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
+      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases2[a4.placements[0].atlas].animated) - Number(atlases2[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
     }
     return pages.map((page) => {
       let faces = page.fluids.reduce((sum, fluid) => sum + fluid.quads.sprites.length, 0);
@@ -104183,12 +104529,13 @@ gl_FragDepth=readDepth(vUv);
       }
       const positions = new Float32Array(faces * 12), normals = new Float32Array(faces * 12);
       const uvs = new Float32Array(faces * 8), uvBounds = new Float32Array(faces * 16), colors = new Float32Array(faces * 12);
+      const shade = new Float32Array(faces * 4).fill(1);
       const outputIndices = new Uint32Array(faces * 6);
       const blockIndices = new Uint16Array(faces);
       let vertex2 = 0, indexOffset = 0;
       for (const entry of page.entries) {
         const template = templateData[templates[entry]];
-        const atlas = atlases[template.atlas];
+        const atlas = atlases2[template.atlas];
         const placement = locations.get(template.atlas);
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104212,6 +104559,7 @@ gl_FragDepth=readDepth(vUv);
             normals[vertex2 * 3] = template.normals[source * 3];
             normals[vertex2 * 3 + 1] = template.normals[source * 3 + 1];
             normals[vertex2 * 3 + 2] = template.normals[source * 3 + 2];
+            shade[vertex2] = template.shade?.[source] ?? 1;
             uvs[vertex2 * 2] = mapU(template.uvs[source * 2]);
             uvs[vertex2 * 2 + 1] = mapV(template.uvs[source * 2 + 1]);
             uvBounds[vertex2 * 4] = mapU(template.uvBounds[source * 4]);
@@ -104227,7 +104575,7 @@ gl_FragDepth=readDepth(vUv);
         }
       }
       for (const { quads, x: x4, y: y5, z: z4, data, tint } of page.fluids) {
-        const atlas = atlases[data.atlas];
+        const atlas = atlases2[data.atlas];
         const placement = page.placements[0];
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104264,11 +104612,11 @@ gl_FragDepth=readDepth(vUv);
           indexOffset += 6;
         }
       }
-      return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices, blockIndices };
+      return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, shade, indices: outputIndices, blockIndices };
     });
   }
   function sectionGeometryTransferables(pages) {
-    return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer, page.blockIndices.buffer]);
+    return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.shade.buffer, page.indices.buffer, page.blockIndices.buffer]);
   }
 
   // src/world/SectionWorker.ts
@@ -104331,7 +104679,7 @@ gl_FragDepth=readDepth(vUv);
   var WATER_TINT = new Color(4159204).toArray();
   function toInput(entries, maxAtlasSize, fluids, lighting) {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
-    const atlases = [];
+    const atlases2 = [];
     const atlasIds = /* @__PURE__ */ new Map();
     const templateIds = /* @__PURE__ */ new Map();
     const input = {
@@ -104354,9 +104702,9 @@ gl_FragDepth=readDepth(vUv);
       if (id === void 0) {
         let atlas = atlasIds.get(template.atlas);
         if (atlas === void 0) {
-          atlas = atlases.length;
+          atlas = atlases2.length;
           atlasIds.set(template.atlas, atlas);
-          atlases.push(template.atlas);
+          atlases2.push(template.atlas);
           input.atlases.push({ width: template.atlas.image.width, height: template.atlas.image.height, animated: template.atlas.hasAnimation });
         }
         let data = templateCache.get(template);
@@ -104374,6 +104722,7 @@ gl_FragDepth=readDepth(vUv);
             uvs: new Float32Array(quads * 8),
             uvBounds: new Float32Array(quads * 16),
             colors: new Float32Array(quads * 12),
+            shade: new Float32Array(quads * 4),
             indices: new Uint16Array(quads * 6),
             cullFaces: new Uint8Array(template.cullFaces),
             biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
@@ -104385,6 +104734,7 @@ gl_FragDepth=readDepth(vUv);
           const uv = template.geometry.getAttribute("uv");
           const bounds = template.geometry.getAttribute("uvBounds");
           const color3 = template.geometry.getAttribute("color");
+          const shade = template.geometry.getAttribute("shade");
           for (let vertex2 = 0; vertex2 < quads * 4; vertex2++) {
             data.positions.set([position.getX(vertex2), position.getY(vertex2), position.getZ(vertex2)], vertex2 * 3);
             data.normals.set([normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2)], vertex2 * 3);
@@ -104396,6 +104746,7 @@ gl_FragDepth=readDepth(vUv);
               bounds?.getW(vertex2) ?? 1
             ], vertex2 * 4);
             data.colors.set([color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1], vertex2 * 3);
+            data.shade[vertex2] = shade?.getX(vertex2) ?? 1;
           }
           for (let i5 = 0; i5 < data.indices.length; i5++) data.indices[i5] = indices.getX(i5) - 4 * Math.floor(i5 / 6);
           templateCache.set(template, data);
@@ -104415,9 +104766,9 @@ gl_FragDepth=readDepth(vUv);
         if (!atlas) continue;
         let id = atlasIds.get(atlas);
         if (id === void 0) {
-          id = atlases.length;
+          id = atlases2.length;
           atlasIds.set(atlas, id);
-          atlases.push(atlas);
+          atlases2.push(atlas);
           input.atlases.push({ width: atlas.image.width, height: atlas.image.height, animated: atlas.hasAnimation });
         }
         input.fluids[kind] = {
@@ -104428,7 +104779,7 @@ gl_FragDepth=readDepth(vUv);
         };
       }
     }
-    return { input, atlases };
+    return { input, atlases: atlases2 };
   }
   var SectionMesh = class _SectionMesh extends Group {
     constructor() {
@@ -104443,23 +104794,23 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
-      return this.fromPages(buildSectionGeometry(input), atlases);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
+      return this.fromPages(buildSectionGeometry(input), atlases2);
     }
     /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
     static async buildAsync(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
       const worker = SectionWorker.shared();
       const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
-      return this.fromPages(pages, atlases);
+      return this.fromPages(pages, atlases2);
     }
-    static fromPages(pages, atlases) {
+    static fromPages(pages, atlases2) {
       const section = new _SectionMesh();
       for (const page of pages) {
         const canvas = createCanvas(page.width, page.height);
         const context = canvas.getContext("2d");
         for (const { atlas, x: x4, y: y5 } of page.placements) {
-          context.drawImage(atlases[atlas].image.canvas, x4, y5);
+          context.drawImage(atlases2[atlas].image.canvas, x4, y5);
         }
         const geometry = new BufferGeometry();
         geometry.setAttribute("position", new Float32BufferAttribute(page.positions.buffer, 3));
@@ -104467,10 +104818,11 @@ gl_FragDepth=readDepth(vUv);
         geometry.setAttribute("uv", new Float32BufferAttribute(page.uvs.buffer, 2));
         geometry.setAttribute("uvBounds", new Float32BufferAttribute(page.uvBounds.buffer, 4));
         geometry.setAttribute("color", new Float32BufferAttribute(page.colors.buffer, 3));
+        geometry.setAttribute("shade", new Float32BufferAttribute(page.shade.buffer, 1));
         geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        const transparent = page.layer === 2 ? atlases[page.placements[0].atlas].hasTranslucency : page.layer === 1;
+        const transparent = page.layer === 2 ? atlases2[page.placements[0].atlas].hasTranslucency : page.layer === 1;
         const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
         material.side = FrontSide;
         if (page.layer === 2) {
@@ -104485,7 +104837,7 @@ gl_FragDepth=readDepth(vUv);
         section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
         for (const { atlas: id, x: x4, y: y5 } of page.placements) {
-          const atlas = atlases[id];
+          const atlas = atlases2[id];
           if (!atlas.hasAnimation) continue;
           unsubscribe.push(atlas.subscribe(() => {
             context.clearRect(x4, y5, atlas.image.width, atlas.image.height);