save tile texture id into map

game/main/src/map_rendering/chunk_rebuild.rs

@@ -44,43 +44,30 @@ fn chunk_rebuilder(
 	mut chunks: ResMut<PhosChunkRegistry>,
 	atlas: Res<ChunkAtlas>,
 	heightmap: Res<Map>,
-	tile_assets: Res<Assets<TileAsset>>,
-	tile_mappers: Res<Assets<TileMapperAsset>>,
 	mut meshes: ResMut<Assets<Mesh>>,
-	biome_painters: Res<Assets<BiomePainterAsset>>,
-	painter: Res<CurrentBiomePainter>,
 ) {
 	if queue.queue.len() == 0 {
 		return;
 	}
 	queue.queue.dedup();
 
+	let chunk_indices = queue.queue.clone();
+	let pool = AsyncComputeTaskPool::get();
+
 	for chunk_index in &queue.queue {
 		let chunk = chunks.chunks[*chunk_index];
 		// commands.entity(chunk).remove::<Handle<Mesh>>();
 		commands.entity(chunk).despawn();
 	}
 
-	let b_painter = biome_painters.get(painter.handle.clone());
-
-	let cur_painter = b_painter.unwrap();
-
 	let chunk_meshes: Vec<_> = queue
 		.queue
 		.par_iter()
 		.map(|idx| {
-			return prepare_chunk_mesh(
-				&heightmap.chunks[*idx],
-				&heightmap,
-				cur_painter,
-				&tile_assets,
-				&tile_mappers,
-			);
+			return prepare_chunk_mesh(&heightmap.chunks[*idx], &heightmap);
 		})
 		.collect();
 
-	let pool = AsyncComputeTaskPool::get();
-
 	for (mesh, collider_data, pos, index) in chunk_meshes {
 		let mut chunk = commands.spawn((
 			MaterialMeshBundle {

game/main/src/map_rendering/map_init.rs

@@ -13,7 +13,7 @@ use crate::{
 	prelude::{ChunkAtlas, PhosChunk, PhosChunkRegistry, PhosMap},
 	shader_extensions::chunk_material::ChunkMaterial,
 	utlis::{
-		chunk_utils::{prepare_chunk_mesh, prepare_chunk_mesh_with_collider},
+		chunk_utils::{paint_map, prepare_chunk_mesh, prepare_chunk_mesh_with_collider},
 		render_distance_system::RenderDistanceVisibility,
 	},
 };
@@ -110,7 +110,14 @@ fn finalize_texture(
 	map.regenerate = true;
 }
 
-fn create_map(mut commands: Commands, mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>) {
+fn create_map(
+	mut commands: Commands,
+	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
+	tile_assets: Res<Assets<TileAsset>>,
+	tile_mappers: Res<Assets<TileMapperAsset>>,
+	biome_painters: Res<Assets<BiomePainterAsset>>,
+	painter: Res<CurrentBiomePainter>,
+) {
 	let config = GenerationConfig {
 		layers: vec![
 			GeneratorLayer {
@@ -180,7 +187,11 @@ fn create_map(mut commands: Commands, mut cam: Query<(&mut Transform, Entity), W
 		size: UVec2::splat(1024 / Chunk::SIZE as u32),
 		// size: UVec2::splat(1),
 	};
-	let heightmap = generate_heightmap(&config, 4);
+	let mut heightmap = generate_heightmap(&config, 4);
+
+	let b_painter = biome_painters.get(painter.handle.clone());
+	let cur_painter = b_painter.unwrap();
+	paint_map(&mut heightmap, cur_painter, &tile_assets, &tile_mappers);
 
 	let (mut cam_t, cam_entity) = cam.single_mut();
 	cam_t.translation = heightmap.get_center();
@@ -197,24 +208,17 @@ fn spawn_map(
 	mut meshes: ResMut<Assets<Mesh>>,
 	atlas: Res<ChunkAtlas>,
 	mut map: ResMut<PhosMap>,
-	tile_assets: Res<Assets<TileAsset>>,
-	tile_mappers: Res<Assets<TileMapperAsset>>,
-	biome_painters: Res<Assets<BiomePainterAsset>>,
-	painter: Res<CurrentBiomePainter>,
 ) {
 	if !map.ready || !map.regenerate {
 		return;
 	}
-	let b_painter = biome_painters.get(painter.handle.clone());
 	map.regenerate = false;
 
-	let cur_painter = b_painter.unwrap();
-
 	let chunk_meshes: Vec<_> = heightmap
 		.chunks
 		.par_iter()
 		.map(|chunk: &Chunk| {
-			return prepare_chunk_mesh_with_collider(chunk, &heightmap, cur_painter, &tile_assets, &tile_mappers);
+			return prepare_chunk_mesh_with_collider(chunk, &heightmap);
 		})
 		.collect();
 

game/main/src/utlis/chunk_utils.rs

@@ -2,6 +2,7 @@
 use bevy::log::*;
 use bevy::{asset::Assets, ecs::system::Res, math::Vec3, render::mesh::Mesh};
 use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
+use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use world_generation::{
 	biome_painter::BiomePainterAsset,
 	chunk_colliders::generate_chunk_collider,
@@ -12,16 +13,41 @@ use world_generation::{
 	tile_mapper::TileMapperAsset,
 };
 
-pub fn prepare_chunk_mesh(
-	chunk: &Chunk,
-	heightmap: &Map,
+pub fn paint_map(
+	map: &mut Map,
 	painter: &BiomePainterAsset,
-	tile_assets: &Res<Assets<TileAsset>>,
-	tile_mappers: &Res<Assets<TileMapperAsset>>,
-) -> (Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
+	tiles: &Res<Assets<TileAsset>>,
+	mappers: &Res<Assets<TileMapperAsset>>,
+) {
+	map.chunks.par_iter_mut().for_each(|chunk: &mut Chunk| {
+		paint_chunk(chunk, painter, tiles, mappers);
+	});
+}
+
+pub fn paint_chunk(
+	chunk: &mut Chunk,
+	painter: &BiomePainterAsset,
+	tiles: &Res<Assets<TileAsset>>,
+	mappers: &Res<Assets<TileMapperAsset>>,
+) {
+	for z in 0..Chunk::SIZE {
+		for x in 0..Chunk::SIZE {
+			let idx = x + z * Chunk::SIZE;
+			let height = chunk.heights[idx];
+			let moisture = chunk.moisture[idx];
+			let temperature = chunk.temperature[idx];
+			let biome = mappers.get(painter.sample_biome(moisture, temperature));
+			let tile_handle = biome.unwrap().sample_tile(height);
+			let tile = tiles.get(tile_handle).unwrap();
+			chunk.textures[idx] = [tile.texture_id, tile.side_texture_id];
+		}
+	}
+}
+
+pub fn prepare_chunk_mesh(chunk: &Chunk, heightmap: &Map) -> (Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
 	#[cfg(feature = "tracing")]
 	let _gen_mesh = info_span!("Generate Chunk").entered();
-	let mesh = generate_chunk_mesh(chunk, &heightmap, painter, &tile_assets, &tile_mappers);
+	let mesh = generate_chunk_mesh(chunk, &heightmap);
 	let col_data = generate_chunk_collider(chunk, &heightmap);
 
 	return (
@@ -32,15 +58,8 @@ pub fn prepare_chunk_mesh(
 	);
 }
 
-pub fn prepare_chunk_mesh_with_collider(
-	chunk: &Chunk,
-	heightmap: &Map,
-	painter: &BiomePainterAsset,
-	tile_assets: &Res<Assets<TileAsset>>,
-	tile_mappers: &Res<Assets<TileMapperAsset>>,
-) -> (Mesh, Collider, Vec3, usize) {
-	let (mesh, (col_verts, col_indicies), pos, index) =
-		prepare_chunk_mesh(chunk, heightmap, painter, tile_assets, tile_mappers);
+pub fn prepare_chunk_mesh_with_collider(chunk: &Chunk, heightmap: &Map) -> (Mesh, Collider, Vec3, usize) {
+	let (mesh, (col_verts, col_indicies), pos, index) = prepare_chunk_mesh(chunk, heightmap);
 	let collider: Collider;
 	{
 		#[cfg(feature = "tracing")]