minerender 2.1.0-alpha.119 → 2.1.0-alpha.120

package/dist/bundle.js

@@ -95481,6 +95481,7 @@ ${shader.fragmentShader}`.replace(
     classicSkinTextureCoordinates: () => classicSkinTextureCoordinates,
     computeMorphedAttributes: () => computeMorphedAttributes,
     computeTangents: () => computeTangents,
+    copySectionLight: () => copySectionLight,
     createCanvas: () => createCanvas,
     createFluidGeometry: () => createFluidGeometry,
     createGuiTextGeometry: () => createGuiTextGeometry,
@@ -95533,6 +95534,7 @@ ${shader.fragmentShader}`.replace(
     sampleEntityAnimation: () => sampleEntityAnimation,
     sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
+    sampleSectionLight: () => sampleSectionLight,
     sectionGeometryTransferables: () => sectionGeometryTransferables,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
@@ -107197,11 +107199,20 @@ gl_FragDepth=readDepth(vUv);
       const { root, expected } = await this.readNBT(data, location, options);
       const level = root.Level?.type === "compound" ? root.Level.value : root;
       const dataVersion = root.DataVersion?.type === "int" ? root.DataVersion.value : void 0;
+      const sections = this.compounds(level.sections ?? level.Sections, "sections");
+      const lightFlagName = level.isLightOn ? "isLightOn" : "LightPopulated";
+      const lightFlag = level[lightFlagName];
+      if (lightFlag && (lightFlag.type !== "byte" || lightFlag.value !== 0 && lightFlag.value !== 1)) {
+        throw new MineRenderError(`Anvil ${lightFlagName} must be a byte containing 0 or 1`);
+      }
+      const modernLighting = root.Level?.type !== "compound" || sections.some((section) => section.Palette || section.BlockStates || section.block_states);
+      const lightValid = lightFlag ? lightFlag.value === 1 : modernLighting ? false : void 0;
       const chunk = {
         x: this.integer(level.xPos, "xPos"),
         z: this.integer(level.zPos, "zPos"),
         dataVersion,
-        sections: []
+        sections: [],
+        ...lightValid !== void 0 ? { lightValid } : {}
       };
       if ((chunk.x % 32 + 32) % 32 !== location.x || (chunk.z % 32 + 32) % 32 !== location.z) {
         throw new MineRenderError("Anvil chunk coordinates do not match its region location");
@@ -107211,7 +107222,7 @@ gl_FragDepth=readDepth(vUv);
       }
       const numericStates = /* @__PURE__ */ new Map();
       let legacyMappings;
-      for (const section of this.compounds(level.sections ?? level.Sections, "sections")) {
+      for (const section of sections) {
         const y5 = this.integer(section.Y, "section Y");
         let data2;
         if (section.Blocks || section.Data || section.Add) {
@@ -107241,7 +107252,8 @@ gl_FragDepth=readDepth(vUv);
         }
         if (chunk.sections.some((section2) => section2.y === y5)) throw new MineRenderError(`Duplicate Anvil section Y ${y5}`);
         const biomes = this.biomes(section.biomes);
-        chunk.sections.push({ y: y5, data: data2, ...biomes ? { biomes } : {} });
+        const light = this.light(section, y5, chunk.lightValid);
+        chunk.sections.push({ y: y5, data: data2, ...biomes ? { biomes } : {}, ...light ? { light } : {} });
       }
       for (const entry of this.compounds(level.block_entities ?? level.TileEntities, "block entities")) {
         const x4 = this.integer(entry.x, "block entity x") - chunk.x * 16;
@@ -107294,6 +107306,18 @@ gl_FragDepth=readDepth(vUv);
         return { position: [...position.value.value], nbt: { type: "compound", value } };
       });
     }
+    static light(section, y5, valid) {
+      const light = {};
+      for (const [name2, channel] of [["BlockLight", "block"], ["SkyLight", "sky"]]) {
+        const tag = section[name2];
+        if (!tag) continue;
+        if (tag.type !== "byteArray" || !Array.isArray(tag.value) || tag.value.length !== 2048) {
+          throw new MineRenderError(`Anvil section ${y5} ${name2} must contain 2048 bytes`);
+        }
+        light[channel] = Uint8Array.from(tag.value);
+      }
+      return light.block || light.sky || valid ? light : void 0;
+    }
     static biomes(tag) {
       if (!tag) return void 0;
       if (tag.type !== "compound") throw new MineRenderError("Anvil biomes must be a compound");
@@ -107894,12 +107918,48 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/MineRenderWorld.ts
   init_FluidQuads();
+
+  // src/world/WorldLight.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  function copySectionLight(light) {
+    const copy = {};
+    for (const channel of ["block", "sky"]) {
+      const bytes = light[channel];
+      if (bytes === void 0) continue;
+      if (!(bytes instanceof Uint8Array) || bytes.length !== 2048) {
+        throw new RangeError(`Section ${channel} light must contain 2048 packed bytes`);
+      }
+      copy[channel] = new Uint8Array(bytes);
+    }
+    return copy;
+  }
+  function sampleSectionLight(light, index) {
+    if (!light) return void 0;
+    const shift = (index & 1) * 4;
+    return {
+      block: (light.block?.[index >> 1] ?? 0) >> shift & 15,
+      sky: (light.sky?.[index >> 1] ?? 0) >> shift & 15
+    };
+  }
+
+  // src/world/MineRenderWorld.ts
   var MineRenderWorld = class {
     constructor(scene, options = {}) {
       this._chunks = /* @__PURE__ */ new Map();
       this.biomes = /* @__PURE__ */ new Map();
+      this.light = /* @__PURE__ */ new Map();
+      this.lightValidity = /* @__PURE__ */ new Map();
+      this.highestSkySection = /* @__PURE__ */ new Map();
       this.pendingCulling = /* @__PURE__ */ new Map();
+      if (options.savedLighting && !options.sectionMeshing) throw new TypeError("savedLighting requires sectionMeshing");
+      if (options.ambientLight !== void 0 && (!Number.isFinite(options.ambientLight) || options.ambientLight < 0 || options.ambientLight > 1)) {
+        throw new RangeError("ambientLight must be a number from 0 to 1");
+      }
       this.scene = scene;
+      this.savedLighting = options.savedLighting ?? false;
+      this.ambientLight = options.ambientLight ?? 0;
       if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
       if (options.renderEntities) this.entities = new WorldEntities(scene);
     }
@@ -107921,6 +107981,24 @@ gl_FragDepth=readDepth(vUv);
       const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
       return this.biomes.get(`${cx}_${cz}`)?.get(cy)?.[Math.floor(lx / 4) + Math.floor(lz / 4) * 4 + Math.floor(ly / 4) * 16];
     }
+    getLightAt(posOrX, y5, z4) {
+      if (typeof posOrX === "number") return this.getLightAt(new Vector3(posOrX, y5, z4));
+      if (isTripleArray(posOrX)) return this.getLightAt(new Vector3(...posOrX));
+      this.validatePosBounds(posOrX);
+      const { x: x4, y: py, z: pz } = posOrX;
+      const cx = Math.floor(x4 / 16), cy = Math.floor(py / 16), cz = Math.floor(pz / 16);
+      const key = `${cx}_${cz}`, top = this.highestSkySection.get(key);
+      const sample = sampleSectionLight(this.light.get(key)?.get(cy), (x4 & 15) + (pz & 15) * 16 + (py & 15) * 256);
+      return top !== void 0 && cy > top ? { block: sample?.block ?? 0, sky: 15 } : sample;
+    }
+    lightLevelAt(x4, y5, z4) {
+      const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16), key = `${cx}_${cz}`;
+      if (this.lightValidity.get(key) === false) return 255;
+      const top = this.highestSkySection.get(key);
+      if (top !== void 0 && cy > top) return 15;
+      const sample = sampleSectionLight(this.light.get(key)?.get(cy), (x4 & 15) + (z4 & 15) * 16 + (y5 & 15) * 256);
+      return sample ? Math.max(sample.block, sample.sky) : 255;
+    }
     async setBlockAt(posOrX, yOrBlock, z4, block) {
       if (typeof posOrX == "number") {
         return this.setBlockAt(new Vector3(posOrX, yOrBlock, z4), block);
@@ -108035,7 +108113,7 @@ gl_FragDepth=readDepth(vUv);
         }
       }
     }
-    /** Replaces a chunk column's blocks and biome samples and, with `renderEntities`, its supported saved mobs. */
+    /** Replaces a chunk column's blocks, biomes, and saved light and, with `renderEntities`, its supported saved mobs. */
     async placeChunk(chunk, executor) {
       if (![chunk.x, chunk.z].every(Number.isSafeInteger)) {
         throw new RangeError("Chunk column coordinates must be safe integers");
@@ -108043,6 +108121,11 @@ gl_FragDepth=readDepth(vUv);
       if (!chunk.sections.every((section) => Number.isSafeInteger(section.y))) {
         throw new RangeError("Chunk section coordinates must be safe integers");
       }
+      const lights = /* @__PURE__ */ new Map();
+      for (const section of chunk.sections) {
+        const light = section.light ?? (chunk.lightValid === true ? {} : void 0);
+        if (light) lights.set(section.y, copySectionLight(light));
+      }
       this.entities?.clearColumn(chunk.x, chunk.z);
       const placeEntities = this.entities?.prepare(chunk.entities, [chunk.x, chunk.z]);
       const changes = /* @__PURE__ */ new Map();
@@ -108058,6 +108141,15 @@ gl_FragDepth=readDepth(vUv);
       }
       try {
         await this.clearChunkColumn(chunk.x, chunk.z);
+        const columnKey = `${chunk.x}_${chunk.z}`;
+        if (lights.size) this.light.set(columnKey, lights);
+        for (const [y5, light] of lights) {
+          if (light.sky) this.highestSkySection.set(columnKey, Math.max(y5, this.highestSkySection.get(columnKey) ?? -Infinity));
+        }
+        if (chunk.lightValid !== void 0) this.lightValidity.set(columnKey, chunk.lightValid);
+        if (this.savedLighting) {
+          for (const y5 of lights.keys()) this.markSectionChanged({ x: chunk.x, y: y5, z: chunk.z });
+        }
         for (const section of chunk.sections) {
           if (section.biomes) {
             const position = new Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -108127,6 +108219,12 @@ gl_FragDepth=readDepth(vUv);
     }
     async clearChunkColumn(x4, z4) {
       this.biomes.delete(`${x4}_${z4}`);
+      if (this.savedLighting) {
+        for (const y5 of this.light.get(`${x4}_${z4}`)?.keys() ?? []) this.markSectionChanged({ x: x4, y: y5, z: z4 });
+      }
+      this.light.delete(`${x4}_${z4}`);
+      this.lightValidity.delete(`${x4}_${z4}`);
+      this.highestSkySection.delete(`${x4}_${z4}`);
       const previous = [...this._chunks.entries()].filter(([, section]) => section.x === x4 && section.z === z4);
       for (const [key, section] of previous) {
         this._chunks.delete(key);
@@ -108136,7 +108234,8 @@ gl_FragDepth=readDepth(vUv);
       }
     }
     markSectionChanged(chunk) {
-      if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingCulling.set(chunk, "all");
+      const current = this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`);
+      if (current && current === chunk) this.pendingCulling.set(current, "all");
       for (let dy = -1; dy <= 1; dy++) {
         for (let dz = -1; dz <= 1; dz++) {
           for (let dx = -1; dx <= 1; dx++) {
@@ -108164,6 +108263,9 @@ gl_FragDepth=readDepth(vUv);
       const chunks = [...this._chunks.values()];
       this._chunks.clear();
       this.biomes.clear();
+      this.light.clear();
+      this.lightValidity.clear();
+      this.highestSkySection.clear();
       for (const chunk of chunks) {
         await chunk.dispose();
       }
@@ -108226,6 +108328,7 @@ gl_FragDepth=readDepth(vUv);
                 }
               }
               for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
+              await chunk.refreshLight(indices === "all" ? void 0 : indices);
             }
             await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
           }
@@ -108266,7 +108369,23 @@ gl_FragDepth=readDepth(vUv);
             }
             await chunk.refreshBiomes();
             await this._chunks.get(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
-          }
+          },
+          this.savedLighting ? (x5, y6, z5) => this.lightLevelAt(x5, y6, z5) : void 0,
+          async () => {
+            if (this._chunks.get(key) !== chunk) return;
+            const columnKey = `${x4}_${z4}`, column = this.light.get(columnKey);
+            if (!column?.delete(y5)) return;
+            if (!column.size) this.light.delete(columnKey);
+            this.highestSkySection.delete(columnKey);
+            for (const [y6, light] of column) {
+              if (light.sky) this.highestSkySection.set(columnKey, Math.max(y6, this.highestSkySection.get(columnKey) ?? -Infinity));
+            }
+            if (this.savedLighting) {
+              this.markSectionChanged(chunk);
+              await this.updateCulling([]);
+            }
+          },
+          this.ambientLight
         );
         this._chunks.set(key, chunk);
       }
@@ -108321,12 +108440,46 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
   init_FluidQuads();
+
+  // src/world/_light/FaceLight.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  function lightBrightness(level, ambient = 0) {
+    if (level === 255) return 1;
+    const curve = level / (60 - 3 * level);
+    return curve + ambient * (1 - curve);
+  }
+  function quadLightIndex(positions, normals, quad) {
+    const start = quad * 12;
+    let axis = 0;
+    if (Math.abs(normals[start + 1]) > Math.abs(normals[start + axis])) axis = 1;
+    if (Math.abs(normals[start + 2]) > Math.abs(normals[start + axis])) axis = 2;
+    const positive2 = normals[start + axis] > 0;
+    const boundary = positive2 ? 8 : -8;
+    for (let vertex2 = 0; vertex2 < 4; vertex2++) {
+      if (Math.abs(positions[start + vertex2 * 3 + axis] - boundary) > 16e-4) return 0;
+    }
+    return axis * 2 + (positive2 ? 1 : 2);
+  }
+  function fluidLightLevel(center, neighbor) {
+    return Math.max(center === 255 ? 15 : center, neighbor === 255 ? 15 : neighbor);
+  }
+  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 } = input;
+    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight } = 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 (fluids && fluids.cells.length !== 5832) throw new RangeError("Section fluid cells must cover an 18\xD718\xD718 neighborhood");
     if (fluids?.waterTints && fluids.waterTints.length !== 4096 * 3) throw new RangeError("Section water tints must contain RGB for 4096 cells");
+    if (light && (light.length !== 5832 || light.some((level) => level > 15 && level !== 255))) {
+      throw new RangeError("Section light must cover an 18\xD718\xD718 neighborhood with levels from 0 to 15 or 255");
+    }
+    if (ambientLight !== void 0 && (!Number.isFinite(ambientLight) || ambientLight < 0 || ambientLight > 1)) {
+      throw new RangeError("Section ambient light must be a number from 0 to 1");
+    }
     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) {
@@ -108431,8 +108584,10 @@ gl_FragDepth=readDepth(vUv);
         const offsetX = indices[entry] % 16 * 16;
         const offsetY = Math.floor(indices[entry] / 256) * 16;
         const offsetZ = Math.floor(indices[entry] / 16) % 16 * 16;
+        const lightIndex = (offsetY / 16 + 1) * 324 + (offsetZ / 16 + 1) * 18 + offsetX / 16 + 1;
         for (let quad = 0; quad < template.quads; quad++) {
           if (cullMasks[entry] & template.cullFaces[quad]) continue;
+          const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
           const start = vertex2;
           for (let corner = 0; corner < 4; corner++, vertex2++) {
             const source = quad * 4 + corner;
@@ -108448,9 +108603,9 @@ gl_FragDepth=readDepth(vUv);
             uvBounds[vertex2 * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
             uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
             uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
-            colors[vertex2 * 3] = template.colors[source * 3];
-            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1];
-            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2];
+            colors[vertex2 * 3] = template.colors[source * 3] * brightness;
+            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1] * brightness;
+            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2] * brightness;
           }
           for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
         }
@@ -108460,8 +108615,13 @@ gl_FragDepth=readDepth(vUv);
         const placement = page.placements[0];
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
+        const lightIndex = (y5 + 1) * 324 + (z4 + 1) * 18 + x4 + 1;
         for (let quad = 0; quad < quads.sprites.length; quad++) {
           const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
+          const brightness = light ? lightBrightness(fluidLightLevel(
+            light[lightIndex],
+            light[lightIndex + (quads.normals[quad * 12 + 1] < 0 ? -324 : 324)]
+          ), ambientLight) : 1;
           const start = vertex2;
           for (let corner = 0; corner < 4; corner++, vertex2++) {
             const source = quad * 4 + corner;
@@ -108479,7 +108639,9 @@ gl_FragDepth=readDepth(vUv);
               mapU((rect[0] + rect[2]) / atlas.width),
               mapV(1 - rect[1] / atlas.height)
             ], vertex2 * 4);
-            colors.set(tint, vertex2 * 3);
+            colors[vertex2 * 3] = tint[0] * brightness;
+            colors[vertex2 * 3 + 1] = tint[1] * brightness;
+            colors[vertex2 * 3 + 2] = tint[2] * brightness;
           }
           outputIndices.set([start, start + 1, start + 2, start, start + 2, start + 3], indexOffset);
           indexOffset += 6;
@@ -108550,7 +108712,7 @@ gl_FragDepth=readDepth(vUv);
   // src/world/SectionMesh.ts
   var templateCache = /* @__PURE__ */ new WeakMap();
   var WATER_TINT = new Color(4159204).toArray();
-  function toInput(entries, maxAtlasSize, fluids) {
+  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 atlasIds = /* @__PURE__ */ new Map();
@@ -108562,7 +108724,8 @@ gl_FragDepth=readDepth(vUv);
       cullMasks: new Uint8Array(entries.length),
       templateData: [],
       atlases: [],
-      maxAtlasSize
+      maxAtlasSize,
+      ...lighting
     };
     for (let i4 = 0; i4 < entries.length; i4++) {
       const { index, template, cullMask } = entries[i4];
@@ -108650,13 +108813,13 @@ gl_FragDepth=readDepth(vUv);
       this.ownedMeshes = [];
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
-    static build(entries, maxAtlasSize = 2048, fluids) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids);
+    static build(entries, maxAtlasSize = 2048, fluids, lighting) {
+      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
       return this.fromPages(buildSectionGeometry(input), atlases);
     }
     /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
-    static async buildAsync(entries, maxAtlasSize = 2048, fluids) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids);
+    static async buildAsync(entries, maxAtlasSize = 2048, fluids, lighting) {
+      const { input, atlases } = 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);
@@ -108726,12 +108889,15 @@ gl_FragDepth=readDepth(vUv);
   init_CubeFace();
   var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
-    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged) {
+    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
       this.onBlocksChanged = onBlocksChanged;
       this.sectionModels = sectionModels;
       this.neighborCell = neighborCell;
       this.biomeAt = biomeAt;
       this.onBiomesChanged = onBiomesChanged;
+      this.lightAt = lightAt;
+      this.onLightCleared = onLightCleared;
+      this.ambientLight = ambientLight;
       this.data = new ChunkData();
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.sectionBlocks = /* @__PURE__ */ new Map();
@@ -109013,6 +109179,13 @@ gl_FragDepth=readDepth(vUv);
     positionAt(index) {
       return [this.x * 16 + index % 16, this.y * 16 + Math.floor(index / 256), this.z * 16 + Math.floor(index / 16) % 16];
     }
+    /** Refreshes saved lighting after adjacent columns load or unload, including columns with only light data. */
+    async refreshLight(indices) {
+      if (!this.lightAt) return;
+      for (const index of indices ?? this.renderedBlocks.keys()) {
+        if (this.renderedBlocks.has(index)) this.meshDirty = true;
+      }
+    }
     biomePosition(index, blockState3, stored) {
       const position = this.positionAt(index), name2 = blockState3.key?.toNamespacedString();
       if (stored.properties?.half === "upper" && (name2 === "minecraft:tall_grass" || name2 === "minecraft:large_fern")) position[1]--;
@@ -109190,7 +109363,23 @@ gl_FragDepth=readDepth(vUv);
           fluids[kind] = await this.sectionModels.fluidAtlas(kind, state?.key?.root);
         }
       }
-      const next = entries.length || fluids ? await SectionMesh.buildAsync(entries, this.sectionModels.maxAtlasSize, fluids) : void 0;
+      let light;
+      if (this.lightAt) {
+        light = new Uint8Array(18 * 18 * 18);
+        for (let y5 = -1; y5 <= 16; y5++) {
+          for (let z4 = -1; z4 <= 16; z4++) {
+            for (let x4 = -1; x4 <= 16; x4++) {
+              light[(y5 + 1) * 324 + (z4 + 1) * 18 + x4 + 1] = this.lightAt(this.x * 16 + x4, this.y * 16 + y5, this.z * 16 + z4);
+            }
+          }
+        }
+      }
+      const next = entries.length || fluids ? await SectionMesh.buildAsync(
+        entries,
+        this.sectionModels.maxAtlasSize,
+        fluids,
+        light ? { light, ambientLight: this.ambientLight } : void 0
+      ) : void 0;
       if (generation !== this.meshGeneration) {
         next?.dispose();
         return;
@@ -109222,6 +109411,7 @@ gl_FragDepth=readDepth(vUv);
       this.biomes = void 0;
       if (notify) {
         await this.onBiomesChanged?.(void 0);
+        await this.onLightCleared?.();
         await this.onBlocksChanged?.(positions);
       }
     }