minerender 2.1.0-alpha.67 → 2.1.0-alpha.69

package/dist/browser/index.mjs

@@ -258,7 +258,8 @@ var init_Caching = __esm({
           this.entityModelCache,
           this.entityTextureCache,
           this.entityAnimationCache,
-          this.blockEntityIndexCache
+          this.blockEntityIndexCache,
+          this.fontCache
         ];
       }
       static clear() {
@@ -305,6 +306,7 @@ var init_Caching = __esm({
     _Caching.entityTextureCache = _Caching.createAssetCache();
     _Caching.entityAnimationCache = _Caching.createAssetCache();
     _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+    _Caching.fontCache = _Caching.createAssetCache();
     Caching = _Caching;
   }
 });
@@ -4247,8 +4249,8 @@ var init_EntityObject = __esm({
 // src/three/BufferGeometryUtils.js
 import {
   BufferAttribute as BufferAttribute4,
-  BufferGeometry as BufferGeometry2,
-  Float32BufferAttribute as Float32BufferAttribute4,
+  BufferGeometry as BufferGeometry4,
+  Float32BufferAttribute as Float32BufferAttribute6,
   InterleavedBuffer,
   InterleavedBufferAttribute,
   TriangleFanDrawMode,
@@ -4267,7 +4269,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new BufferGeometry2();
+  const mergedGeometry = new BufferGeometry4();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4776,8 +4778,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new Float32BufferAttribute4(modifiedPosition, 3);
-  const morphedNormalAttribute = new Float32BufferAttribute4(modifiedNormal, 3);
+  const morphedPositionAttribute = new Float32BufferAttribute6(modifiedPosition, 3);
+  const morphedNormalAttribute = new Float32BufferAttribute6(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -5027,7 +5029,7 @@ var init_ItemTints = __esm({
 });
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color8, Euler as Euler7, Matrix4 as Matrix49 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute5, Color as Color9, Euler as Euler7, Matrix4 as Matrix49 } from "three";
 function isModelObject(obj) {
   return obj.isModelObject;
 }
@@ -5141,7 +5143,7 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new Color8(tint);
+                  const color = new Color9(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
@@ -5270,7 +5272,7 @@ var init_fluidBlocks = __esm({
 });
 
 // src/model/fluid/FluidGeometry.ts
-import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute5 } from "three";
+import { BufferGeometry as BufferGeometry6, Float32BufferAttribute as Float32BufferAttribute7 } from "three";
 function getBlockFluidState(key, state) {
   const rule = key && fluidRules[key.toNamespacedString()];
   if (rule) return {
@@ -5288,7 +5290,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new BufferGeometry4();
+  const geometry = new BufferGeometry6();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -5387,9 +5389,9 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new Float32BufferAttribute5(positions, 3));
-  geometry.setAttribute("normal", new Float32BufferAttribute5(normals, 3));
-  geometry.setAttribute("uv", new Float32BufferAttribute5(uvs, 2));
+  geometry.setAttribute("position", new Float32BufferAttribute7(positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute7(normals, 3));
+  geometry.setAttribute("uv", new Float32BufferAttribute7(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
@@ -5409,7 +5411,7 @@ __export(FluidModelObject_exports, {
   FluidModelObject: () => FluidModelObject,
   sampleFluid: () => sampleFluid
 });
-import { BufferAttribute as BufferAttribute6, Color as Color9, DoubleSide as DoubleSide3 } from "three";
+import { BufferAttribute as BufferAttribute6, Color as Color10, DoubleSide as DoubleSide4 } from "three";
 function sampleFluid(kind, sample) {
   const cells = [];
   const key = [];
@@ -5460,7 +5462,7 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new Color9(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new Color10(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
         geometry.setAttribute("color", new BufferAttribute6(colors, 3));
@@ -5477,7 +5479,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = DoubleSide3;
+          material.side = DoubleSide4;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -5731,6 +5733,101 @@ var BlockEntities = class {
 // src/assets/index.ts
 init_BlockStates();
 init_Entities();
+
+// src/assets/Fonts.ts
+init_AssetKey();
+init_AssetLoader();
+init_AssetParsers();
+init_ModelTextures();
+init_Caching();
+var Fonts = class {
+  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, []));
+  }
+  static relatedKey(assetType, id, origin) {
+    const key = AssetKey.parse(assetType, id);
+    key.root = origin.root;
+    return key;
+  }
+  static async load(key, parents) {
+    const serialized = key.serialize();
+    if (parents.includes(serialized)) throw new Error(`Cyclic font reference: ${key.toNamespacedString()}`);
+    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();
+    for (const asset of stack) {
+      for (const provider of asset.providers) {
+        if (provider.filter?.uniform || provider.filter?.jp) continue;
+        let provided;
+        switch (provider.type) {
+          case "bitmap":
+          case "minecraft:bitmap":
+            provided = await this.bitmap(provider, key);
+            break;
+          case "space":
+          case "minecraft:space":
+            provided = new Map(Object.entries(provider.advances).map(([character, advance]) => [
+              character,
+              { x: 0, y: 0, width: 0, height: 0, scale: 1, ascent: 0, advance }
+            ]));
+            break;
+          case "reference":
+          case "minecraft:reference":
+            provided = (await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized])).glyphs;
+            break;
+          default:
+            continue;
+        }
+        for (const [character, glyph] of provided) {
+          if (character !== "\0" && !glyphs.has(character)) glyphs.set(character, glyph);
+        }
+      }
+    }
+    return { glyphs };
+  }
+  static async bitmap(provider, fontKey) {
+    const rows = provider.chars.map((row) => [...row]);
+    const columns = rows[0]?.length;
+    if (!columns || rows.some((row) => row.length !== columns)) {
+      throw new Error(`Invalid character grid in font ${fontKey.toNamespacedString()}`);
+    }
+    const key = this.relatedKey("textures", provider.file, fontKey);
+    const image = await ModelTextures.get(key);
+    if (!image) throw new Error(`Could not load font texture ${key.toNamespacedString()}`);
+    const width = Math.floor(image.width / columns), height = Math.floor(image.height / rows.length);
+    if (!width || !height) throw new Error(`Font texture ${key.toNamespacedString()} is smaller than its character grid`);
+    const scale = (provider.height ?? 8) / height;
+    const pixels = image.data.getImageData(0, 0, image.width, image.height).data;
+    const glyphs = /* @__PURE__ */ new Map();
+    rows.forEach((row, rowIndex) => row.forEach((character, columnIndex) => {
+      if (character === "\0") return;
+      const x = columnIndex * width, y = rowIndex * height;
+      let occupiedWidth = 0;
+      for (let column = width - 1; column >= 0 && !occupiedWidth; column--) {
+        for (let row2 = 0; row2 < height; row2++) {
+          if (pixels[((y + row2) * image.width + x + column) * 4 + 3] !== 0) {
+            occupiedWidth = column + 1;
+            break;
+          }
+        }
+      }
+      glyphs.set(character, {
+        image: image.data.canvas,
+        x,
+        y,
+        width,
+        height,
+        scale,
+        ascent: provider.ascent,
+        advance: Math.floor(occupiedWidth * scale + 0.5) + 1
+      });
+    }));
+    return glyphs;
+  }
+};
+
+// src/assets/index.ts
 init_ModelTextures();
 init_Models();
 init_source();
@@ -8729,7 +8826,137 @@ function copyDataTexture(source) {
 
 // src/gui/GuiHelper.ts
 init_AssetKey();
+
+// src/gui/GuiText.ts
+import { BufferGeometry as BufferGeometry2, Color as Color8, Float32BufferAttribute as Float32BufferAttribute4 } from "three";
+async function layoutGuiText(text, options = {}) {
+  const maxWidth = options.maxWidth ?? Infinity, lineHeight = options.lineHeight ?? 9;
+  if (!(maxWidth > 0) || !Number.isFinite(lineHeight) || lineHeight <= 0) {
+    throw new Error("Text wrap width and line height must be positive");
+  }
+  const font = await Fonts.get(options.font);
+  const runs = typeof text === "string" ? [{ text }] : text;
+  const glyphs = [], lineWidths = [];
+  let line = [], width = 0;
+  let trailingNewline = false;
+  const finishLine = (entries) => {
+    let x = 0;
+    for (const entry of entries) {
+      glyphs.push({ ...entry, x, y: lineWidths.length * lineHeight });
+      x += entry.advance;
+    }
+    lineWidths.push(x);
+  };
+  for (const run of runs) {
+    const style = {
+      color: run.color ?? options.color ?? 16777215,
+      bold: run.bold ?? options.bold ?? false,
+      italic: run.italic ?? options.italic ?? false
+    };
+    for (const character of run.text.replace(/\r\n?/g, "\n")) {
+      trailingNewline = character === "\n";
+      if (character === "\n") {
+        finishLine(line);
+        line = [];
+        width = 0;
+        continue;
+      }
+      const glyph = font.glyphs.get(character);
+      const advance = (glyph?.advance ?? 6) + (style.bold ? 1 : 0);
+      line.push({ character, glyph, advance, style, x: 0, y: 0 });
+      width += advance;
+      while (width > maxWidth && line.length > 1) {
+        let space = -1;
+        for (let i = 0; i < line.length; i++) if (line[i].character === " ") space = i;
+        const split = space >= 0 ? space : line.length - 1;
+        if (split > 0) finishLine(line.slice(0, split));
+        line = line.slice(split + (space >= 0 ? 1 : 0));
+        width = line.reduce((sum, entry) => sum + entry.advance, 0);
+      }
+    }
+  }
+  if (line.length || !lineWidths.length || trailingNewline) finishLine(line);
+  return { glyphs, lineWidths, width: Math.max(0, ...lineWidths), height: lineWidths.length * lineHeight };
+}
+function createGuiTextGeometry(layout, shadow = true) {
+  const batches = [];
+  for (const isShadow of shadow ? [true, false] : [false]) {
+    let batch;
+    for (const entry of layout.glyphs) {
+      const { glyph, style } = entry;
+      if (glyph && !glyph.image) continue;
+      if (!batch || batch.image !== glyph?.image) {
+        batch = { image: glyph?.image, positions: [], uvs: [], colors: [], indices: [] };
+        batches.push(batch);
+      }
+      const color = new Color8(isShadow ? (style.color & 16579836) >> 2 : style.color);
+      const offset = isShadow ? 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;
+      const shear = (y) => style.italic ? 1 - 0.25 * y : 0;
+      const quad = (left, upper, right, lower, boldOffset) => {
+        const base = batch.positions.length / 3;
+        const x = entry.x + offset + boldOffset, y = entry.y + offset;
+        batch.positions.push(
+          x + left + shear(upper),
+          -y - upper,
+          0,
+          x + right + shear(upper),
+          -y - upper,
+          0,
+          x + left + shear(lower),
+          -y - lower,
+          0,
+          x + right + shear(lower),
+          -y - lower,
+          0
+        );
+        const u0 = glyph ? glyph.x / glyph.image.width : 0;
+        const u1 = glyph ? (glyph.x + glyph.width) / glyph.image.width : 1;
+        const v0 = glyph ? 1 - glyph.y / glyph.image.height : 1;
+        const v1 = glyph ? 1 - (glyph.y + glyph.height) / glyph.image.height : 0;
+        batch.uvs.push(u0, v0, u1, v0, u0, v1, u1, v1);
+        for (let i = 0; i < 4; i++) batch.colors.push(color.r, color.g, color.b);
+        batch.indices.push(base, base + 2, base + 1, base + 2, base + 3, base + 1);
+      };
+      for (const boldOffset of style.bold ? [0, 1] : [0]) {
+        if (glyph) quad(0, top, width, top + height, boldOffset);
+        else {
+          quad(0, 0, 5, 1, boldOffset);
+          quad(0, 7, 5, 8, boldOffset);
+          quad(0, 1, 1, 7, boldOffset);
+          quad(4, 1, 5, 7, boldOffset);
+        }
+      }
+    }
+  }
+  return batches.map(({ image, positions, uvs, colors, indices }) => ({ image, geometry: new BufferGeometry2().setAttribute("position", new Float32BufferAttribute4(positions, 3)).setAttribute("uv", new Float32BufferAttribute4(uvs, 2)).setAttribute("color", new Float32BufferAttribute4(colors, 3)).setIndex(indices) }));
+}
+
+// src/gui/GuiHelper.ts
 var GuiHelper = class {
+  /** Sizes a tooltip around supplied text; the first entry is its title. */
+  static async tooltip(lines, options = {}) {
+    if (!lines.length) return [];
+    const { position = [0, 0], titleGap = 2, lineHeight = 10, shadow = true, ...style } = options;
+    const textOptions = { ...style, lineHeight, shadow };
+    const layouts = await Promise.all(lines.map((line) => layoutGuiText(line, textOptions)));
+    const width = Math.max(...layouts.map((layout) => layout.width));
+    const height = layouts.reduce((sum, layout) => sum + layout.height, 0) - 2 + (lines.length > 1 ? titleGap : 0);
+    const layers = ["background", "frame"].map((part) => ({
+      name: `tooltip-${part}`,
+      texture: `minecraft:gui/sprites/tooltip/${part}`,
+      position: [position[0] - 12, position[1] - 12],
+      size: [width + 24, height + 24]
+    }));
+    let y = position[1];
+    lines.forEach((text, index) => {
+      layers.push({ ...textOptions, name: `tooltip-line-${index}`, text, position: [position[0], y] });
+      y += layouts[index].height + (index === 0 ? titleGap : 0);
+    });
+    return layers;
+  }
   static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
     const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
     return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
@@ -8793,6 +9020,85 @@ var GuiHelper = class {
   }
 };
 
+// src/gui/GuiTextureGeometry.ts
+import { BufferGeometry as BufferGeometry3, Float32BufferAttribute as Float32BufferAttribute5, PlaneGeometry } from "three";
+function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
+  if (crop || !scaling || scaling.type === "stretch") {
+    const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
+    const geometry = new PlaneGeometry(width, height);
+    const uv = geometry.getAttribute("uv");
+    for (let i = 0; i < uv.count; i++) {
+      uv.setXY(
+        i,
+        (x + uv.getX(i) * w) / imageWidth,
+        1 - (y + (1 - uv.getY(i)) * h) / imageHeight
+      );
+    }
+    return geometry;
+  }
+  const sw = scaling.width, sh = scaling.height;
+  if (![sw, sh].every((value) => Number.isInteger(value) && value > 0)) {
+    throw new Error("GUI sprite dimensions must be positive integers");
+  }
+  if (![width, height].every((value) => Number.isFinite(value) && value >= 0)) {
+    throw new Error("GUI output dimensions must be finite and nonnegative");
+  }
+  const positions = [], uvs = [], normals = [], indices = [];
+  function quad(x, y, w, h, u, v, uw, vh) {
+    if (w <= 0 || h <= 0) return;
+    const index = positions.length / 3;
+    const left = x - width / 2, top = height / 2 - y;
+    positions.push(left, top, 0, left + w, top, 0, left, top - h, 0, left + w, top - h, 0);
+    uvs.push(
+      u / sw,
+      1 - v / sh,
+      (u + uw) / sw,
+      1 - v / sh,
+      u / sw,
+      1 - (v + vh) / sh,
+      (u + uw) / sw,
+      1 - (v + vh) / sh
+    );
+    normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1);
+    indices.push(index, index + 2, index + 1, index + 2, index + 3, index + 1);
+  }
+  function tile(x, y, w, h, u, v, tw, th) {
+    for (let dy = 0; dy < h; dy += th) {
+      for (let dx = 0; dx < w; dx += tw) {
+        const cw = Math.min(tw, w - dx), ch = Math.min(th, h - dy);
+        quad(x + dx, y + dy, cw, ch, u, v, cw, ch);
+      }
+    }
+  }
+  if (scaling.type === "tile") {
+    tile(0, 0, width, height, 0, 0, sw, sh);
+  } else {
+    let segments = function(size, sourceSize, start, end) {
+      if (size === sourceSize) return [[0, size, 0, sourceSize]];
+      start = Math.min(start, Math.floor(size / 2));
+      end = Math.min(end, Math.floor(size / 2));
+      return [
+        [0, start, 0, start],
+        [start, size - start - end, start, sourceSize - start - end],
+        [size - end, end, sourceSize - end, end]
+      ];
+    };
+    const border = typeof scaling.border === "number" ? { left: scaling.border, top: scaling.border, right: scaling.border, bottom: scaling.border } : scaling.border;
+    if (!border || typeof scaling.border === "number" && scaling.border <= 0 || ![border.left, border.top, border.right, border.bottom].every((value) => Number.isInteger(value) && value >= 0) || border.left + border.right >= sw || border.top + border.bottom >= sh) {
+      throw new Error("GUI nine-slice borders must be nonnegative integers with a nonempty center");
+    }
+    const columns = segments(width, sw, border.left, border.right);
+    const rows = segments(height, sh, border.top, border.bottom);
+    for (const [y, h, v, vh] of rows) {
+      for (const [x, w, u, uw] of columns) {
+        if (w <= 0 || h <= 0) continue;
+        (scaling.stretch_inner ? quad : tile)(x, y, w, h, u, v, uw, vh);
+      }
+    }
+  }
+  return new BufferGeometry3().setAttribute("position", new Float32BufferAttribute5(positions, 3)).setAttribute("normal", new Float32BufferAttribute5(normals, 3)).setAttribute("uv", new Float32BufferAttribute5(uvs, 2)).setIndex(indices);
+}
+
 // src/gui/scene/GuiObject.ts
 init_AssetKey();
 init_ModelTextures();
@@ -8803,7 +9109,7 @@ init_Materials();
 init_ModelObject();
 init_DisplayPosition();
 init_GuiLight();
-import { Box2, Box3 as Box32, Matrix4 as Matrix410, Mesh as Mesh6, PlaneGeometry, Vector2 as Vector23 } from "three";
+import { Box2, Box3 as Box32, DoubleSide as DoubleSide3, Group, Matrix4 as Matrix410, Mesh as Mesh6, MeshBasicMaterial as MeshBasicMaterial5, Vector2 as Vector23 } from "three";
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -8813,6 +9119,7 @@ var GuiObject = class extends SceneObject {
     this.bounds = new Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
+    this.textMaterials = /* @__PURE__ */ new Map();
     this.initialized = false;
   }
   async init() {
@@ -8821,6 +9128,43 @@ var GuiObject = class extends SceneObject {
       let depth = 0;
       for (const [index, layer] of this.textureLayers.entries()) {
         const [x, y] = layer.position ?? [0, 0];
+        if ("text" in layer) {
+          const layout = await layoutGuiText(layer.text, layer);
+          const group = new Group();
+          group.name = `group:${layer.name ?? index}`;
+          group.position.set(x, -y, depth);
+          const [width2, height2] = layer.size ?? [layout.width, layout.height];
+          group.scale.set(layout.width ? width2 / layout.width : 1, height2 / layout.height, 1);
+          this.add(group);
+          const parts = createGuiTextGeometry(layout, layer.shadow);
+          const bounds = new Box32();
+          for (const [partIndex, { image: image2, geometry: geometry2 }] of parts.entries()) {
+            this.geometries.add(geometry2);
+            geometry2.computeBoundingBox();
+            bounds.union(geometry2.boundingBox);
+            let material2 = this.textMaterials.get(image2);
+            if (!material2) {
+              material2 = image2 ? Materials.createGuiCanvasMaterial(image2) : new MeshBasicMaterial5({ transparent: true, depthWrite: false, side: DoubleSide3, toneMapped: false });
+              material2.vertexColors = true;
+              this.textMaterials.set(image2, material2);
+              this.ownedMaterials.add(material2);
+            }
+            const mesh2 = new Mesh6(geometry2, material2);
+            mesh2.name = `mesh:${layer.name ?? index}:${partIndex}`;
+            mesh2.renderOrder = index + partIndex / (parts.length + 1) * 0.5;
+            group.add(mesh2);
+          }
+          group.updateMatrix();
+          bounds.applyMatrix4(group.matrix);
+          this.bounds.expandByPoint(new Vector23(x, y));
+          this.bounds.expandByPoint(new Vector23(x + width2, y + height2));
+          if (!bounds.isEmpty()) {
+            this.bounds.expandByPoint(new Vector23(bounds.min.x, -bounds.max.y));
+            this.bounds.expandByPoint(new Vector23(bounds.max.x, -bounds.min.y));
+          }
+          depth += 0.01;
+          continue;
+        }
         if ("item" in layer) {
           const [width2, height2] = layer.size ?? [16, 16];
           const item = await this.createItem(layer, index);
@@ -8844,18 +9188,10 @@ var GuiObject = class extends SceneObject {
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
         const material = await this.loadMaterial(key);
         const image = material.map.image;
-        const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
-        const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new PlaneGeometry(width, height);
+        const scaling = layer.crop ? void 0 : (await ModelTextures.getMeta(key))?.gui?.scaling;
+        const [width, height] = layer.size ?? (layer.crop ? layer.crop.slice(2) : scaling && scaling.type !== "stretch" ? [scaling.width, scaling.height] : [image.width, image.height]);
+        const geometry = createGuiTextureGeometry(width, height, image.width, image.height, layer.crop, scaling);
         this.geometries.add(geometry);
-        const uv = geometry.getAttribute("uv");
-        for (let i = 0; i < uv.count; i++) {
-          uv.setXY(
-            i,
-            (cropX + uv.getX(i) * cropWidth) / image.width,
-            1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
-          );
-        }
         const mesh = new Mesh6(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
@@ -8920,10 +9256,11 @@ var GuiObject = class extends SceneObject {
     for (const geometry of this.geometries) geometry.dispose();
     this.geometries.clear();
     for (const material of this.ownedMaterials) {
-      material.map.dispose();
+      material.map?.dispose();
       material.dispose();
     }
     this.ownedMaterials.clear();
+    this.textMaterials.clear();
     this.bounds.makeEmpty();
     this.initialized = false;
     super.disposeAndRemoveAllChildren();
@@ -12489,7 +12826,7 @@ init_util();
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
-import { DataTexture as DataTexture2, DoubleSide as DoubleSide4, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial6, SRGBColorSpace as SRGBColorSpace6 } from "three";
+import { DataTexture as DataTexture2, DoubleSide as DoubleSide5, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial6, SRGBColorSpace as SRGBColorSpace6 } from "three";
 
 // src/skin/SkinImage.ts
 init_Caching();
@@ -12574,7 +12911,7 @@ var SkinTextures = class {
     texture.colorSpace = SRGBColorSpace6;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new MeshBasicMaterial6({ map: texture, transparent, side: transparent ? DoubleSide4 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
+    return new MeshBasicMaterial6({ map: texture, transparent, side: transparent ? DoubleSide5 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -14782,8 +15119,8 @@ init_Model();
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry6, Float32BufferAttribute as Float32BufferAttribute6, Group, Mesh as Mesh9 } from "three";
-var SectionMesh = class _SectionMesh extends Group {
+import { BufferGeometry as BufferGeometry8, Float32BufferAttribute as Float32BufferAttribute8, Group as Group2, Mesh as Mesh9 } from "three";
+var SectionMesh = class _SectionMesh extends Group2 {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -14856,11 +15193,11 @@ var SectionMesh = class _SectionMesh extends Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new BufferGeometry6();
-      geometry.setAttribute("position", new Float32BufferAttribute6(positions, 3));
-      geometry.setAttribute("normal", new Float32BufferAttribute6(normals, 3));
-      geometry.setAttribute("uv", new Float32BufferAttribute6(uvs, 2));
-      geometry.setAttribute("color", new Float32BufferAttribute6(colors, 3));
+      const geometry = new BufferGeometry8();
+      geometry.setAttribute("position", new Float32BufferAttribute8(positions, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute8(normals, 3));
+      geometry.setAttribute("uv", new Float32BufferAttribute8(uvs, 2));
+      geometry.setAttribute("color", new Float32BufferAttribute8(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
@@ -15114,6 +15451,7 @@ export {
   EntityObject,
   Env,
   FluidModelObject,
+  Fonts,
   Geometries,
   GuiHelper,
   GuiLight,
@@ -15185,6 +15523,8 @@ export {
   computeTangents,
   createCanvas,
   createFluidGeometry,
+  createGuiTextGeometry,
+  createGuiTextureGeometry,
   createImage,
   entityAnimationTime,
   estimateBytesUsed,
@@ -15213,6 +15553,7 @@ export {
   isTransformable,
   isTripleArray,
   isVector3,
+  layoutGuiText,
   md5,
   mergeBufferAttributes,
   mergeBufferGeometries,