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

package/dist/browser/index.js

@@ -286,6 +286,7 @@ var init_Caching = __esm({
           this.entityAnimationCache,
           this.blockEntityIndexCache,
           this.fontCache,
+          this.unihexCache,
           this.bannerPatternCache,
           this.mineRenderDataCache,
           this.usernameUuidCache,
@@ -339,6 +340,7 @@ var init_Caching = __esm({
     _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();
@@ -1055,6 +1057,7 @@ var init_Materials = __esm({
       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
@@ -1077,7 +1080,7 @@ var init_Materials = __esm({
             void main()
             {
 
-                if (SHADE) {
+                if (SHADE && shade > 0.5) {
 
                     #ifdef USE_INSTANCING
                         vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
@@ -1186,7 +1189,7 @@ var init_Materials = __esm({
             side: transparent ? import_three5.DoubleSide : import_three5.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 (e) {
           console.warn(e);
@@ -1351,6 +1354,7 @@ var init_AssetParsers = __esm({
       AssetParser2["IMAGE"] = "image";
       AssetParser2["LIST"] = "list";
       AssetParser2["JSON"] = "json";
+      AssetParser2["BINARY"] = "binary";
       return AssetParser2;
     })(AssetParser || {});
   }
@@ -2631,13 +2635,13 @@ function applyElementRotation(rotation, geometry) {
       break;
   }
   if (rotation.rescale) {
-    if (Math.abs(rotation.angle) === 22.5) {
-      const s = 1 / Math.cos(0.39269909262657166);
-      geometry.scale(s, 1, s);
-    } else {
-      const s = 1 / Math.cos(0.7853981852531433);
-      geometry.scale(s, 1, s);
-    }
+    const angle = toRadians(rotation.angle);
+    const s = 1 / Math.max(Math.abs(Math.cos(angle)), Math.abs(Math.sin(angle)));
+    geometry.scale(
+      rotation.axis === "x" /* X */ ? 1 : s,
+      rotation.axis === "y" /* Y */ ? 1 : s,
+      rotation.axis === "z" /* Z */ ? 1 : s
+    );
   }
   geometry.translate(origin.x, origin.y, origin.z);
 }
@@ -2821,7 +2825,7 @@ var init_parser = __esm({
 });
 
 // src/assets/source/HostedAssetSource.ts
-var p4, DEFAULT_OPTIONS, _HostedAssetSource, HostedAssetSource;
+var BINARY_TIMEOUT, p4, DEFAULT_OPTIONS, _HostedAssetSource, HostedAssetSource;
 var init_HostedAssetSource = __esm({
   "src/assets/source/HostedAssetSource.ts"() {
     init_AssetSource();
@@ -2834,6 +2838,7 @@ var init_HostedAssetSource = __esm({
     init_AssetLoader();
     init_parser();
     init_merge();
+    BINARY_TIMEOUT = 6e4;
     p4 = prefix("HostedAssetSource");
     DEFAULT_OPTIONS = {
       retryDefaults: true
@@ -2974,6 +2979,15 @@ var init_HostedAssetSource = __esm({
         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],
@@ -2981,7 +2995,8 @@ var init_HostedAssetSource = __esm({
       ["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;
   }
@@ -4762,6 +4777,178 @@ var init_Entities = __esm({
   }
 });
 
+// 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 y = 0; y < GLYPH_HEIGHT; y++) {
+      rows[y] = parseInt(match[2].slice(y * rowLength, (y + 1) * rowLength), 16);
+      mask |= rows[y];
+    }
+    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 import_zip2.ZipReader(new import_zip2.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 import_zip2.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 (error) {
+    console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error);
+    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 (error) {
+    console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error);
+    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 import_zip2, ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+var init_Unihex = __esm({
+  "src/assets/_fonts/Unihex.ts"() {
+    import_zip2 = require("@zip.js/zip.js");
+    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 y = 0; y < GLYPH_HEIGHT; y++) {
+          for (let x = 0; x < width; x++) {
+            const column = glyph.left + x;
+            if (column < 0 || column >= glyph.bitWidth || !(glyph.rows[y] >>> glyph.bitWidth - column - 1 & 1)) continue;
+            pixels.data.fill(255, (y * width + x) * 4, (y * width + x + 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({
@@ -4772,7 +4959,7 @@ var init_Fonts = __esm({
     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, []));
@@ -4788,6 +4975,7 @@ var init_Fonts = __esm({
         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;
@@ -4806,17 +4994,43 @@ var init_Fonts = __esm({
                 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, 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);
+              }
+            }
           }
-        }
-        return { glyphs };
+        } };
       }
       static async bitmap(provider, fontKey) {
         const rows = provider.chars.map((row) => [...row]);
@@ -4909,6 +5123,13 @@ var init_EntityAnimation = __esm({
 });
 
 // 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 import_three11, ZERO, EntityAnimationPlayer;
 var init_EntityAnimationPlayer = __esm({
   "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -4918,12 +5139,20 @@ var init_EntityAnimationPlayer = __esm({
     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;
@@ -4933,10 +5162,20 @@ var init_EntityAnimationPlayer = __esm({
        * 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 = [];
@@ -4945,7 +5184,8 @@ var init_EntityAnimationPlayer = __esm({
               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);
             }
@@ -4969,7 +5209,7 @@ var init_EntityAnimationPlayer = __esm({
       }
       /** 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);
@@ -4981,12 +5221,14 @@ var init_EntityAnimationPlayer = __esm({
       /** 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;
@@ -4995,8 +5237,30 @@ var init_EntityAnimationPlayer = __esm({
       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 i = 0; i < this._animations.length; i++) {
+          const weight = this._weights[i];
+          if (weight === 0) continue;
+          const sampled = sampleEntityAnimation(this._animations[i], this._time, this.loops[i]);
+          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]);
@@ -5616,7 +5880,7 @@ var init_EntityObject = __esm({
         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();
       }
@@ -5651,15 +5915,31 @@ var init_EntityObject = __esm({
       //<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, i) => {
+            animations[indices[i]] = 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, i) => {
+            weights[indices[i]] = 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.
@@ -5670,42 +5950,59 @@ var init_EntityObject = __esm({
       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((name) => name.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((name) => !targets.has(name.split("#")[0])));
+        const main = selections.get("main");
+        if (main) main.names.push(...Object.keys(this.entityLayers).filter((name) => !selections.has(name.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((name) => this.getLayerGroup(name)), animation, options, this.partPoses);
-          this.animationPlayers.push(player);
+          player.playAnimations(
+            names.map((name) => this.getLayerGroup(name)),
+            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>
@@ -7940,6 +8237,7 @@ async function layoutGuiText(text2, options = {}) {
   }
   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;
@@ -7966,7 +8264,7 @@ async function layoutGuiText(text2, options = {}) {
         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) {
@@ -7994,7 +8292,7 @@ function createGuiTextGeometry(layout, shadow = true) {
         batches.push(batch);
       }
       const color2 = new import_three20.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;
@@ -8024,7 +8322,7 @@ function createGuiTextGeometry(layout, shadow = true) {
         for (let i = 0; i < 4; i++) batch.colors.push(color2.r, color2.g, color2.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);
@@ -9795,6 +10093,10 @@ var init_ModelObject = __esm({
             this.atlas.model.elements?.forEach((el) => {
               const elGeo = this._getBoxGeometryFromElement(el).clone();
               this.geometries.add(elGeo);
+              elGeo.setAttribute("shade", new import_three27.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((_, index) => {
@@ -11299,6 +11601,7 @@ __export(index_browser_exports, {
   toRadians: () => toRadians,
   toTrianglesDrawMode: () => toTrianglesDrawMode,
   trimCanvas: () => trimCanvas,
+  validateAnimationWeights: () => validateAnimationWeights,
   yieldToEventLoop: () => yieldToEventLoop
 });
 module.exports = __toCommonJS(index_browser_exports);
@@ -17666,9 +17969,9 @@ function cached(map, key, load) {
 function compactQuads(geometry, keep) {
   const quads = keep.flatMap((kept, index) => kept ? [index] : []);
   const compact = new import_three41.BufferGeometry();
-  for (const [name, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3 })) {
+  for (const [name, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3, shade: 1 })) {
     const source2 = geometry.getAttribute(name);
-    const defaults = name === "uvBounds" ? [0, 0, 1, 1] : name === "color" ? [1, 1, 1] : void 0;
+    const defaults = name === "uvBounds" ? [0, 0, 1, 1] : name === "color" ? [1, 1, 1] : name === "shade" ? [1] : void 0;
     const values = new Float32Array(quads.length * 4 * size);
     for (let q = 0; q < quads.length; q++) {
       for (let vertex = 0; vertex < 4; vertex++) {
@@ -18916,7 +19219,7 @@ var LIGHT_SAMPLE_OFFSETS = [0, 1, -1, 324, -324, 18, -18];
 
 // 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");
@@ -18934,7 +19237,7 @@ function buildSectionGeometry(input) {
   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");
     }
   }
@@ -18951,8 +19254,8 @@ function buildSectionGeometry(input) {
   const locations = /* @__PURE__ */ new Map();
   for (const [layer, layerAtlases] of [...visibleAtlases].sort(([a], [b]) => a - b)) {
     const firstPage = pages.length;
-    for (const atlas of [...layerAtlases].sort((a, b) => Number(atlases[a].animated) - Number(atlases[b].animated) || (atlases[a].animated ? a - b : atlases[b].height - atlases[a].height))) {
-      const { width, height, animated } = atlases[atlas];
+    for (const atlas of [...layerAtlases].sort((a, b) => Number(atlases2[a].animated) - Number(atlases2[b].animated) || (atlases2[a].animated ? a - b : atlases2[b].height - atlases2[a].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 i = firstPage; !animated && i < pages.length; i++) {
@@ -18995,7 +19298,7 @@ function buildSectionGeometry(input) {
       });
       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,
@@ -19013,7 +19316,7 @@ function buildSectionGeometry(input) {
       const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
       fluidPages.get(fluid).fluids.push({ quads, x, y, z, data, tint });
     }
-    pages.push(...[...fluidPages.values()].sort((a, b) => Number(atlases[a.placements[0].atlas].animated) - Number(atlases[b.placements[0].atlas].animated) || a.placements[0].atlas - b.placements[0].atlas));
+    pages.push(...[...fluidPages.values()].sort((a, b) => Number(atlases2[a.placements[0].atlas].animated) - Number(atlases2[b.placements[0].atlas].animated) || a.placements[0].atlas - b.placements[0].atlas));
   }
   return pages.map((page) => {
     let faces = page.fluids.reduce((sum, fluid) => sum + fluid.quads.sprites.length, 0);
@@ -19025,12 +19328,13 @@ function buildSectionGeometry(input) {
     }
     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 vertex = 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 = (u) => (placement.x + u * atlas.width) / page.width;
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
@@ -19054,6 +19358,7 @@ function buildSectionGeometry(input) {
           normals[vertex * 3] = template.normals[source * 3];
           normals[vertex * 3 + 1] = template.normals[source * 3 + 1];
           normals[vertex * 3 + 2] = template.normals[source * 3 + 2];
+          shade[vertex] = template.shade?.[source] ?? 1;
           uvs[vertex * 2] = mapU(template.uvs[source * 2]);
           uvs[vertex * 2 + 1] = mapV(template.uvs[source * 2 + 1]);
           uvBounds[vertex * 4] = mapU(template.uvBounds[source * 4]);
@@ -19069,7 +19374,7 @@ function buildSectionGeometry(input) {
       }
     }
     for (const { quads, x, y, z, data, tint } of page.fluids) {
-      const atlas = atlases[data.atlas];
+      const atlas = atlases2[data.atlas];
       const placement = page.placements[0];
       const mapU = (u) => (placement.x + u * atlas.width) / page.width;
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
@@ -19106,11 +19411,11 @@ function buildSectionGeometry(input) {
         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
@@ -19170,7 +19475,7 @@ var templateCache = /* @__PURE__ */ new WeakMap();
 var WATER_TINT = new import_three46.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 = {
@@ -19193,9 +19498,9 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
     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);
@@ -19213,6 +19518,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           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,
@@ -19224,6 +19530,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
         const uv = template.geometry.getAttribute("uv");
         const bounds = template.geometry.getAttribute("uvBounds");
         const color2 = template.geometry.getAttribute("color");
+        const shade = template.geometry.getAttribute("shade");
         for (let vertex = 0; vertex < quads * 4; vertex++) {
           data.positions.set([position.getX(vertex), position.getY(vertex), position.getZ(vertex)], vertex * 3);
           data.normals.set([normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex)], vertex * 3);
@@ -19235,6 +19542,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
             bounds?.getW(vertex) ?? 1
           ], vertex * 4);
           data.colors.set([color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1], vertex * 3);
+          data.shade[vertex] = shade?.getX(vertex) ?? 1;
         }
         for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - 4 * Math.floor(i2 / 6);
         templateCache.set(template, data);
@@ -19254,9 +19562,9 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       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] = {
@@ -19267,7 +19575,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       };
     }
   }
-  return { input, atlases };
+  return { input, atlases: atlases2 };
 }
 var SectionMesh = class _SectionMesh extends import_three46.Group {
   constructor() {
@@ -19282,23 +19590,23 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
   }
   /** 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, y } of page.placements) {
-        context.drawImage(atlases[atlas].image.canvas, x, y);
+        context.drawImage(atlases2[atlas].image.canvas, x, y);
       }
       const geometry = new import_three46.BufferGeometry();
       geometry.setAttribute("position", new import_three46.Float32BufferAttribute(page.positions.buffer, 3));
@@ -19306,10 +19614,11 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       geometry.setAttribute("uv", new import_three46.Float32BufferAttribute(page.uvs.buffer, 2));
       geometry.setAttribute("uvBounds", new import_three46.Float32BufferAttribute(page.uvBounds.buffer, 4));
       geometry.setAttribute("color", new import_three46.Float32BufferAttribute(page.colors.buffer, 3));
+      geometry.setAttribute("shade", new import_three46.Float32BufferAttribute(page.shade.buffer, 1));
       geometry.setIndex(new import_three46.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 = import_three46.FrontSide;
       if (page.layer === 2) {
@@ -19324,7 +19633,7 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
-        const atlas = atlases[id];
+        const atlas = atlases2[id];
         if (!atlas.hasAnimation) continue;
         unsubscribe.push(atlas.subscribe(() => {
           context.clearRect(x, y, atlas.image.width, atlas.image.height);