No more ecs

client/rendering/level_renderer.ts

@@ -0,0 +1,130 @@
+import { TEXTURE_SIZE } from "$/common/constants.ts";
+import { CHUNK_SIZE, ClientLevel } from "$/client/level/client_level.ts";
+import { Camera } from "$/client/camera.ts";
+import { AssetManager } from "$/client/assets.ts";
+import { get_sprite_region } from "$/client/sprites.ts";
+import type { MultiPlayerGameMode } from "$/client/game_mode.ts";
+import type { Entity } from "$/client/entity/entity.ts";
+import { RemotePlayer } from "$/client/entity/remote_player.ts";
+import {
+	draw_terrain,
+	flush_batch,
+	push_back_face,
+	push_bottom_face,
+	push_box,
+	push_front_face,
+	push_left_face,
+	push_right_face,
+	push_top_face,
+	set_current_texture,
+	Texture,
+	white_tex,
+} from "$/client/renderer/mod.ts";
+
+const BREAKING_FACES = [
+	push_back_face,
+	push_bottom_face,
+	push_front_face,
+	push_left_face,
+	push_right_face,
+	push_top_face,
+];
+
+// draws the level, like minecraft's LevelRenderer: terrain in layers, block breaking and entities
+export class LevelRenderer {
+	// solid and cutout terrain, drawn before entities
+	render_opaque(level: ClientLevel, camera: Camera) {
+		level.request_meshes(camera);
+		level.update_translucent_sorting(camera);
+
+		set_current_texture(level.image.tex);
+
+		for (const chunk of level.chunks.values()) {
+			const mesh = chunk.meshes.solid;
+			if (mesh) {
+				draw_terrain("solid", mesh.vertex_buffer, mesh.quad_count);
+			}
+		}
+
+		for (const chunk of level.chunks.values()) {
+			const mesh = chunk.meshes.cutout;
+			if (mesh) {
+				draw_terrain("cutout", mesh.vertex_buffer, mesh.quad_count);
+			}
+		}
+	}
+
+	// translucent terrain, drawn after entities so they show through water and glass.
+	// chunks go back to front, and each chunk's quads are already sorted back to front
+	render_translucent(level: ClientLevel, camera: Camera) {
+		const distance_sq = (x: number, z: number) => {
+			const dx = (x + 0.5) * CHUNK_SIZE - camera.x;
+			const dz = (z + 0.5) * CHUNK_SIZE - camera.z;
+			return dx * dx + dz * dz;
+		};
+		const chunks = [...level.chunks.values()]
+			.filter((chunk) => chunk.meshes.translucent)
+			.map((chunk) => ({ mesh: chunk.meshes.translucent!, distance: distance_sq(chunk.x, chunk.z) }))
+			.sort((a, b) => b.distance - a.distance);
+
+		set_current_texture(level.image.tex);
+
+		for (const { mesh } of chunks) {
+			draw_terrain("translucent", mesh.vertex_buffer, mesh.quad_count, mesh.index_buffer);
+		}
+	}
+
+	// every entity but the one the camera is in
+	render_entities(level: ClientLevel, camera_entity: Entity) {
+		flush_batch();
+		set_current_texture(white_tex!);
+
+		for (const entity of level.entities.values()) {
+			if (entity !== camera_entity && entity instanceof RemotePlayer) {
+				render_player(entity);
+			}
+		}
+
+		flush_batch();
+	}
+
+	// the cracks on the block being broken
+	render_destroy_progress(game_mode: MultiPlayerGameMode) {
+		const block = game_mode.destroy_pos;
+		if (!block) {
+			return;
+		}
+
+		const progress = Math.max(0, Math.min(1, game_mode.destroy_progress / game_mode.destroy_time));
+		const stage = Math.round(progress * 8);
+		if (Number.isNaN(stage)) {
+			return;
+		}
+
+		const tex = AssetManager.instance.get<Texture>("bworld:textures");
+		const region = get_sprite_region(`engine:break_${stage}`);
+		for (const push_face of BREAKING_FACES) {
+			push_face(
+				tex,
+				block.x,
+				block.y,
+				block.z,
+				region.x * TEXTURE_SIZE,
+				region.y * TEXTURE_SIZE,
+				TEXTURE_SIZE,
+				TEXTURE_SIZE,
+			);
+		}
+	}
+}
+
+// a box body and head in the player's color
+function render_player(player: RemotePlayer) {
+	const [r, g, b] = player.color;
+	const { x, y, z } = player;
+
+	// body
+	push_box(x - 0.3, y, z - 0.15, 0.6, 1.3, 0.3, r, g, b);
+	// head
+	push_box(x - 0.25, y + 1.3, z - 0.25, 0.5, 0.5, 0.5, 0.95, 0.8, 0.65);
+}