Lighting system

2026-09-25 15:40:09 -03:00
parent 25f8c683bb
commit 4539898c58
12 changed files with 634 additions and 349 deletions
@@ -0,0 +1,176 @@
+// minecraft's lighting: every block has a sky light and a block light level from 0 to 15.
+// sky light starts at 15 above the world and goes straight down without getting weaker until it hits
+// something that isn't fully clear, block light starts at blocks that give off light. both spread to
+// neighbors losing max(1, the neighbor's opacity) per step.
+//
+// minecraft stores light and updates it as blocks change. here it's worked out from scratch for the
+// 3x3 chunks around the chunk being meshed, which gives the same result: light reaches at most 15
+// blocks, so nothing outside those chunks can light the middle one or its border
+
+import { AIR, CHUNK_AREA, CHUNK_HEIGHT, CHUNK_SIZE, ID_MASK } from "$/common/constants.ts";
+
+export const REGION_SIZE = CHUNK_SIZE * 3;
+export const REGION_LAYER = REGION_SIZE * REGION_SIZE;
+export const REGION_VOLUME = REGION_LAYER * CHUNK_HEIGHT;
+// what unloaded chunks and the space below the world are made of: opaque, dark, never shown
+export const REGION_VOID = ID_MASK;
+
+// by numeric block id
+export interface LightTables {
+	opacity: Uint8Array;
+	emission: Uint8Array;
+}
+
+export class LightRegion {
+	// block ids without their state bits, indexed y * REGION_LAYER + z * REGION_SIZE + x
+	blocks = new Uint16Array(REGION_VOLUME);
+	sky = new Uint8Array(REGION_VOLUME);
+	block_light = new Uint8Array(REGION_VOLUME);
+
+	// the lowest y that still sees the sky, per column
+	#heights = new Int32Array(REGION_LAYER);
+	#queue = new Int32Array(1 << 18);
+	#queue_length = 0;
+
+	// the 3x3 chunks around the one being meshed, going +x then +z, starting at -x -z. missing ones are void
+	fill(chunks: (Uint32Array | null)[]) {
+		for (let i = 0; i < 9; i++) {
+			const source = chunks[i];
+			const origin = Math.floor(i / 3) * CHUNK_SIZE * REGION_SIZE + (i % 3) * CHUNK_SIZE;
+			for (let y = 0; y < CHUNK_HEIGHT; y++) {
+				for (let z = 0; z < CHUNK_SIZE; z++) {
+					const to = y * REGION_LAYER + origin + z * REGION_SIZE;
+					if (!source) {
+						this.blocks.fill(REGION_VOID, to, to + CHUNK_SIZE);
+						continue;
+					}
+					const from = y * CHUNK_AREA + z * CHUNK_SIZE;
+					for (let x = 0; x < CHUNK_SIZE; x++) {
+						this.blocks[to + x] = source[from + x] & ID_MASK;
+					}
+				}
+			}
+		}
+	}
+
+	compute(tables: LightTables) {
+		this.#compute_sky(tables);
+		this.#compute_block_light(tables);
+	}
+
+	#compute_sky({ opacity }: LightTables) {
+		const { blocks, sky } = this;
+		sky.fill(0);
+		this.#queue_length = 0;
+
+		// straight down from the top, until something isn't fully clear
+		for (let column = 0; column < REGION_LAYER; column++) {
+			let y = CHUNK_HEIGHT - 1;
+			while (y >= 0 && opacity[blocks[y * REGION_LAYER + column]] === 0) {
+				sky[y * REGION_LAYER + column] = 15;
+				y--;
+			}
+			this.#heights[column] = y + 1;
+		}
+
+		// only the lit cells next to a darker one can spread: the bottom of each column's sunlight,
+		// and the part of it that's beside a neighbor column's shade
+		for (let z = 0; z < REGION_SIZE; z++) {
+			for (let x = 0; x < REGION_SIZE; x++) {
+				const column = z * REGION_SIZE + x;
+				const height = this.#heights[column];
+				let highest_neighbor = height;
+				if (x > 0) highest_neighbor = Math.max(highest_neighbor, this.#heights[column - 1]);
+				if (x < REGION_SIZE - 1) highest_neighbor = Math.max(highest_neighbor, this.#heights[column + 1]);
+				if (z > 0) highest_neighbor = Math.max(highest_neighbor, this.#heights[column - REGION_SIZE]);
+				if (z < REGION_SIZE - 1) {
+					highest_neighbor = Math.max(highest_neighbor, this.#heights[column + REGION_SIZE]);
+				}
+				const top = Math.min(CHUNK_HEIGHT - 1, Math.max(height, highest_neighbor - 1));
+				for (let y = height; y <= top; y++) {
+					this.#push(y * REGION_LAYER + column);
+				}
+			}
+		}
+
+		this.#propagate(sky, opacity, true);
+	}
+
+	#compute_block_light({ opacity, emission }: LightTables) {
+		const { blocks, block_light } = this;
+		block_light.fill(0);
+		this.#queue_length = 0;
+
+		for (let i = 0; i < REGION_VOLUME; i++) {
+			const level = emission[blocks[i]];
+			if (level > 0) {
+				block_light[i] = level;
+				this.#push(i);
+			}
+		}
+
+		this.#propagate(block_light, opacity, false);
+	}
+
+	#push(index: number) {
+		if (this.#queue_length === this.#queue.length) {
+			const bigger = new Int32Array(this.#queue.length * 2);
+			bigger.set(this.#queue);
+			this.#queue = bigger;
+		}
+		this.#queue[this.#queue_length++] = index;
+	}
+
+	// breadth first from everything queued. a cell can be queued again when a brighter path reaches it
+	#propagate(light: Uint8Array, opacity: Uint8Array, is_sky: boolean) {
+		const blocks = this.blocks;
+
+		const spread = (to: number, level: number, down: boolean) => {
+			const block_opacity = opacity[blocks[to]];
+			const next = is_sky && down && level === 15 && block_opacity === 0
+				? 15
+				: level - Math.max(1, block_opacity);
+			if (next > light[to]) {
+				light[to] = next;
+				this.#push(to);
+			}
+		};
+
+		for (let head = 0; head < this.#queue_length; head++) {
+			const index = this.#queue[head];
+			const level = light[index];
+			if (level <= 1) continue;
+
+			const y = Math.floor(index / REGION_LAYER);
+			const rest = index - y * REGION_LAYER;
+			const z = Math.floor(rest / REGION_SIZE);
+			const x = rest - z * REGION_SIZE;
+
+			if (y > 0) spread(index - REGION_LAYER, level, true);
+			if (y < CHUNK_HEIGHT - 1) spread(index + REGION_LAYER, level, false);
+			if (x > 0) spread(index - 1, level, false);
+			if (x < REGION_SIZE - 1) spread(index + 1, level, false);
+			if (z > 0) spread(index - REGION_SIZE, level, false);
+			if (z < REGION_SIZE - 1) spread(index + REGION_SIZE, level, false);
+		}
+		this.#queue_length = 0;
+	}
+}
+
+// what a cell looks like to the mesher, including above and below the world
+export function region_block(region: LightRegion, index: number, y: number) {
+	if (y >= CHUNK_HEIGHT) return AIR;
+	if (y < 0) return REGION_VOID;
+	return region.blocks[index];
+}
+
+export function region_sky(region: LightRegion, index: number, y: number) {
+	if (y >= CHUNK_HEIGHT) return 15;
+	if (y < 0) return 0;
+	return region.sky[index];
+}
+
+export function region_block_light(region: LightRegion, index: number, y: number) {
+	if (y >= CHUNK_HEIGHT || y < 0) return 0;
+	return region.block_light[index];
+}