minerender 2.1.0-alpha.132 → 2.1.0-alpha.133

package/dist/node/index.js

@@ -310,6 +310,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.unihexCache = _Caching.createAssetCache();
+      }
       static {
         this.fontCache = _Caching.createAssetCache();
       }
@@ -352,6 +355,7 @@ var init_Caching = __esm({
           this.entityAnimationCache,
           this.blockEntityIndexCache,
           this.fontCache,
+          this.unihexCache,
           this.bannerPatternCache,
           this.mineRenderDataCache,
           this.usernameUuidCache,
@@ -1409,6 +1413,7 @@ var init_AssetParsers = __esm({
       AssetParser2["IMAGE"] = "image";
       AssetParser2["LIST"] = "list";
       AssetParser2["JSON"] = "json";
+      AssetParser2["BINARY"] = "binary";
       return AssetParser2;
     })(AssetParser || {});
   }
@@ -2881,7 +2886,7 @@ var init_parser = __esm({
 });
 
 // src/assets/source/HostedAssetSource.ts
-var p3, DEFAULT_OPTIONS, HostedAssetSource;
+var BINARY_TIMEOUT, p3, DEFAULT_OPTIONS, HostedAssetSource;
 var init_HostedAssetSource = __esm({
   "src/assets/source/HostedAssetSource.ts"() {
     init_AssetSource();
@@ -2894,6 +2899,7 @@ var init_HostedAssetSource = __esm({
     init_AssetLoader();
     init_parser();
     init_merge();
+    BINARY_TIMEOUT = 6e4;
     p3 = prefix("HostedAssetSource");
     DEFAULT_OPTIONS = {
       retryDefaults: true
@@ -2964,6 +2970,17 @@ var init_HostedAssetSource = __esm({
           }
         };
       }
+      static {
+        this.BINARY = {
+          config(request) {
+            request.timeout = BINARY_TIMEOUT;
+            request.responseType = "arraybuffer";
+          },
+          parse(response) {
+            return { data: new Uint8Array(response.data) };
+          }
+        };
+      }
       static {
         this.PARSER_MAP = /* @__PURE__ */ new Map([
           ["model" /* MODEL */, _HostedAssetSource.MODEL],
@@ -2972,7 +2989,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]
         ]);
       }
       /** Retries missing assets with the `minecraft` namespace and default root. Other failures reject. */
@@ -4858,6 +4876,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 ??= 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 = createCanvas2(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({
@@ -4868,7 +5058,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, []));
@@ -4884,6 +5074,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;
@@ -4902,17 +5093,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]);
@@ -8121,6 +8338,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;
@@ -8147,7 +8365,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) {
@@ -8175,7 +8393,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;
@@ -8205,7 +8423,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);
@@ -19021,7 +19239,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");
@@ -19056,8 +19274,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++) {
@@ -19100,7 +19318,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,
@@ -19118,7 +19336,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);
@@ -19135,7 +19353,7 @@ function buildSectionGeometry(input) {
     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;
@@ -19174,7 +19392,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;
@@ -19276,7 +19494,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 = {
@@ -19299,9 +19517,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);
@@ -19360,9 +19578,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] = {
@@ -19373,7 +19591,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       };
     }
   }
-  return { input, atlases };
+  return { input, atlases: atlases2 };
 }
 var SectionMesh = class _SectionMesh extends import_three46.Group {
   constructor() {
@@ -19388,23 +19606,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 = createCanvas2(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));
@@ -19415,7 +19633,7 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       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) {
@@ -19430,7 +19648,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);