minerender 2.1.0-alpha.132 → 2.1.0-alpha.134

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 || {});
   }
@@ -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]);
@@ -8023,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;
@@ -8049,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) {
@@ -8077,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;
@@ -8107,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);
@@ -9878,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) => {
@@ -17750,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++) {
@@ -19000,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");
@@ -19018,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");
     }
   }
@@ -19035,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++) {
@@ -19079,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,
@@ -19097,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);
@@ -19109,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;
@@ -19138,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]);
@@ -19153,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;
@@ -19190,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
@@ -19254,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 = {
@@ -19277,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);
@@ -19297,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,
@@ -19308,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);
@@ -19319,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);
@@ -19338,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] = {
@@ -19351,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() {
@@ -19366,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));
@@ -19390,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) {
@@ -19408,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);