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

package/dist/bundle.js

@@ -41421,7 +41421,8 @@ void main() {
             this.entityModelCache,
             this.entityTextureCache,
             this.entityAnimationCache,
-            this.blockEntityIndexCache
+            this.blockEntityIndexCache,
+            this.fontCache
           ];
         }
         static clear() {
@@ -41468,6 +41469,7 @@ void main() {
       _Caching.entityTextureCache = _Caching.createAssetCache();
       _Caching.entityAnimationCache = _Caching.createAssetCache();
       _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+      _Caching.fontCache = _Caching.createAssetCache();
       Caching = _Caching;
     }
   });
@@ -93313,6 +93315,7 @@ ${shader.fragmentShader}`.replace(
     EntityObject: () => EntityObject,
     Env: () => Env,
     FluidModelObject: () => FluidModelObject,
+    Fonts: () => Fonts,
     Geometries: () => Geometries,
     GuiHelper: () => GuiHelper,
     GuiLight: () => GuiLight,
@@ -93384,6 +93387,8 @@ ${shader.fragmentShader}`.replace(
     computeTangents: () => computeTangents,
     createCanvas: () => createCanvas,
     createFluidGeometry: () => createFluidGeometry,
+    createGuiTextGeometry: () => createGuiTextGeometry,
+    createGuiTextureGeometry: () => createGuiTextureGeometry,
     createImage: () => createImage,
     entityAnimationTime: () => entityAnimationTime,
     estimateBytesUsed: () => estimateBytesUsed,
@@ -93412,6 +93417,7 @@ ${shader.fragmentShader}`.replace(
     isTransformable: () => isTransformable,
     isTripleArray: () => isTripleArray,
     isVector3: () => isVector3,
+    layoutGuiText: () => layoutGuiText,
     md5: () => md5,
     mergeBufferAttributes: () => mergeBufferAttributes,
     mergeBufferGeometries: () => mergeBufferGeometries,
@@ -93759,6 +93765,104 @@ ${shader.fragmentShader}`.replace(
   // src/assets/index.ts
   init_BlockStates();
   init_Entities();
+
+  // src/assets/Fonts.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 x4 = columnIndex * width, y5 = rowIndex * height;
+        let occupiedWidth = 0;
+        for (let column = width - 1; column >= 0 && !occupiedWidth; column--) {
+          for (let row2 = 0; row2 < height; row2++) {
+            if (pixels[((y5 + row2) * image.width + x4 + column) * 4 + 3] !== 0) {
+              occupiedWidth = column + 1;
+              break;
+            }
+          }
+        }
+        glyphs.set(character, {
+          image: image.data.canvas,
+          x: x4,
+          y: y5,
+          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();
@@ -96789,7 +96893,140 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
   init_AssetKey();
+
+  // src/gui/GuiText.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  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 x4 = 0;
+      for (const entry of entries) {
+        glyphs.push({ ...entry, x: x4, y: lineWidths.length * lineHeight });
+        x4 += entry.advance;
+      }
+      lineWidths.push(x4);
+    };
+    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 i4 = 0; i4 < line.length; i4++) if (line[i4].character === " ") space = i4;
+          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 color2 = new Color(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 = (y5) => style.italic ? 1 - 0.25 * y5 : 0;
+        const quad = (left, upper, right, lower, boldOffset) => {
+          const base = batch.positions.length / 3;
+          const x4 = entry.x + offset + boldOffset, y5 = entry.y + offset;
+          batch.positions.push(
+            x4 + left + shear(upper),
+            -y5 - upper,
+            0,
+            x4 + right + shear(upper),
+            -y5 - upper,
+            0,
+            x4 + left + shear(lower),
+            -y5 - lower,
+            0,
+            x4 + right + shear(lower),
+            -y5 - 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 i4 = 0; i4 < 4; i4++) 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]) {
+          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 BufferGeometry().setAttribute("position", new Float32BufferAttribute(positions, 3)).setAttribute("uv", new Float32BufferAttribute(uvs, 2)).setAttribute("color", new Float32BufferAttribute(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 y5 = position[1];
+      lines.forEach((text, index) => {
+        layers.push({ ...textOptions, name: `tooltip-line-${index}`, text, position: [position[0], y5] });
+        y5 += 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]];
@@ -96858,6 +97095,88 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
+  // src/gui/GuiTextureGeometry.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
+    if (crop || !scaling || scaling.type === "stretch") {
+      const [x4, y5, w4, h5] = crop ?? [0, 0, imageWidth, imageHeight];
+      const geometry = new PlaneGeometry(width, height);
+      const uv = geometry.getAttribute("uv");
+      for (let i4 = 0; i4 < uv.count; i4++) {
+        uv.setXY(
+          i4,
+          (x4 + uv.getX(i4) * w4) / imageWidth,
+          1 - (y5 + (1 - uv.getY(i4)) * h5) / 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(x4, y5, w4, h5, u4, v5, uw, vh) {
+      if (w4 <= 0 || h5 <= 0) return;
+      const index = positions.length / 3;
+      const left = x4 - width / 2, top = height / 2 - y5;
+      positions.push(left, top, 0, left + w4, top, 0, left, top - h5, 0, left + w4, top - h5, 0);
+      uvs.push(
+        u4 / sw,
+        1 - v5 / sh,
+        (u4 + uw) / sw,
+        1 - v5 / sh,
+        u4 / sw,
+        1 - (v5 + vh) / sh,
+        (u4 + uw) / sw,
+        1 - (v5 + 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(x4, y5, w4, h5, u4, v5, tw, th) {
+      for (let dy = 0; dy < h5; dy += th) {
+        for (let dx = 0; dx < w4; dx += tw) {
+          const cw = Math.min(tw, w4 - dx), ch = Math.min(th, h5 - dy);
+          quad(x4 + dx, y5 + dy, cw, ch, u4, v5, 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 border2 = typeof scaling.border === "number" ? { left: scaling.border, top: scaling.border, right: scaling.border, bottom: scaling.border } : scaling.border;
+      if (!border2 || typeof scaling.border === "number" && scaling.border <= 0 || ![border2.left, border2.top, border2.right, border2.bottom].every((value) => Number.isInteger(value) && value >= 0) || border2.left + border2.right >= sw || border2.top + border2.bottom >= sh) {
+        throw new Error("GUI nine-slice borders must be nonnegative integers with a nonempty center");
+      }
+      const columns = segments(width, sw, border2.left, border2.right);
+      const rows = segments(height, sh, border2.top, border2.bottom);
+      for (const [y5, h5, v5, vh] of rows) {
+        for (const [x4, w4, u4, uw] of columns) {
+          if (w4 <= 0 || h5 <= 0) continue;
+          (scaling.stretch_inner ? quad : tile)(x4, y5, w4, h5, u4, v5, uw, vh);
+        }
+      }
+    }
+    return new BufferGeometry().setAttribute("position", new Float32BufferAttribute(positions, 3)).setAttribute("normal", new Float32BufferAttribute(normals, 3)).setAttribute("uv", new Float32BufferAttribute(uvs, 2)).setIndex(indices);
+  }
+
   // src/gui/scene/index.ts
   init_dirname();
   init_buffer2();
@@ -96886,6 +97205,7 @@ property list uchar int vertex_index
       this.bounds = new Box2();
       this.geometries = /* @__PURE__ */ new Set();
       this.ownedMaterials = /* @__PURE__ */ new Set();
+      this.textMaterials = /* @__PURE__ */ new Map();
       this.initialized = false;
     }
     async init() {
@@ -96894,6 +97214,43 @@ property list uchar int vertex_index
         let depth = 0;
         for (const [index, layer] of this.textureLayers.entries()) {
           const [x4, y5] = 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(x4, -y5, 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 Box3();
+            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 MeshBasicMaterial({ transparent: true, depthWrite: false, side: DoubleSide, toneMapped: false });
+                material2.vertexColors = true;
+                this.textMaterials.set(image2, material2);
+                this.ownedMaterials.add(material2);
+              }
+              const mesh2 = new Mesh(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 Vector2(x4, y5));
+            this.bounds.expandByPoint(new Vector2(x4 + width2, y5 + height2));
+            if (!bounds.isEmpty()) {
+              this.bounds.expandByPoint(new Vector2(bounds.min.x, -bounds.max.y));
+              this.bounds.expandByPoint(new Vector2(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);
@@ -96917,18 +97274,10 @@ property list uchar int vertex_index
           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 i4 = 0; i4 < uv.count; i4++) {
-            uv.setXY(
-              i4,
-              (cropX + uv.getX(i4) * cropWidth) / image.width,
-              1 - (cropY + (1 - uv.getY(i4)) * cropHeight) / image.height
-            );
-          }
           const mesh = new Mesh(geometry, material);
           mesh.name = `mesh:${layer.name ?? index}`;
           mesh.position.set(x4 + width / 2, -y5 - height / 2, depth);
@@ -96993,10 +97342,11 @@ property list uchar int vertex_index
       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();