Less blocking terrain mesh generation

src/client/terrain/mod.rs

@@ -14,6 +14,7 @@ impl Plugin for TerrainPlugin {
         app.insert_resource(ChunkManager::new());
         app.insert_resource(util::TextureManager::new());
         app.insert_resource(resources::RenderMaterials::new());
+        app.insert_resource(resources::MesherTasks::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
         app.add_event::<terrain_events::WorldRegenerateEvent>();
@@ -36,6 +37,7 @@ impl Plugin for TerrainPlugin {
                 Update,
                 terrain_systems::handle_terrain_regeneration_events_system,
             );
+            app.add_systems(Update, terrain_systems::handle_chunk_tasks_system);
         }
     }
 }

src/client/terrain/resources.rs

@@ -1,3 +1,5 @@
+use bevy::tasks::Task;
+
 use crate::prelude::*;
 
 #[derive(Resource)]
@@ -9,6 +11,37 @@ impl SpawnAreaLoaded {
     }
 }
 
+pub enum MeshType {
+    Solid,
+    Transparent,
+}
+
+pub struct MeshTask(pub Task<Option<Mesh>>);
+pub struct FutureChunkMesh {
+    pub position: Vec3,
+    pub mesh_task: MeshTask,
+    pub mesh_type: MeshType,
+}
+
+#[derive(Resource)]
+pub struct MesherTasks {
+    pub task_list: Vec<FutureChunkMesh>,
+}
+
+impl Default for MesherTasks {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MesherTasks {
+    pub fn new() -> Self {
+        MesherTasks {
+            task_list: Vec::new(),
+        }
+    }
+}
+
 #[derive(Resource)]
 pub struct RenderMaterials {
     pub transparent_material: Option<Handle<StandardMaterial>>,

src/client/terrain/systems.rs

@@ -1,5 +1,5 @@
-use terrain_resources::RenderMaterials;
-use terrain_util::create_cross_mesh_for_chunk;
+use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool};
+use terrain_resources::{FutureChunkMesh, MeshTask, MeshType, MesherTasks, RenderMaterials};
 
 use crate::prelude::*;
 
@@ -46,7 +46,7 @@ pub fn generate_world_system(
     mut client: ResMut<RenetClient>,
     mut chunk_manager: ResMut<ChunkManager>,
 ) {
-    let render_distance = Vec3::new(4.0, 4.0, 4.0);
+    let render_distance = Vec3::new(8.0, 4.0, 8.0);
 
     info!("Sending chunk requests for chunks");
 
@@ -71,12 +71,11 @@ pub fn generate_world_system(
 
 pub fn handle_chunk_mesh_update_events_system(
     mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
     chunk_manager: ResMut<ChunkManager>,
     mut chunk_mesh_update_events: EventReader<terrain_events::ChunkMeshUpdateEvent>,
     mut mesh_query: Query<(Entity, &terrain_components::ChunkMesh)>,
     texture_manager: ResMut<terrain_util::TextureManager>,
-    materials: Res<RenderMaterials>,
+    mut tasks: ResMut<MesherTasks>,
 ) {
     for event in chunk_mesh_update_events.read() {
         info!(
@@ -91,20 +90,16 @@ pub fn handle_chunk_mesh_update_events_system(
                         commands.entity(entity).despawn();
                     }
                 }
-                add_chunk_objects(
-                    &mut commands,
-                    &mut meshes,
-                    chunk,
-                    &texture_manager,
-                    &materials,
-                );
-                add_cross_objects(
-                    &mut commands,
-                    chunk,
-                    &materials,
-                    &texture_manager,
-                    &mut meshes,
-                );
+                tasks.task_list.push(FutureChunkMesh {
+                    position: chunk.position,
+                    mesh_task: create_cube_mesher_task(chunk, &texture_manager),
+                    mesh_type: terrain_resources::MeshType::Solid,
+                });
+                tasks.task_list.push(FutureChunkMesh {
+                    position: chunk.position,
+                    mesh_task: create_cross_mesher_task(chunk, &texture_manager),
+                    mesh_type: terrain_resources::MeshType::Transparent,
+                });
             }
             None => {
                 println!("No chunk found");
@@ -113,73 +108,92 @@ pub fn handle_chunk_mesh_update_events_system(
     }
 }
 
-fn add_chunk_objects(
-    commands: &mut Commands,
-    meshes: &mut ResMut<Assets<Mesh>>,
+fn create_cube_mesher_task(
     chunk: &Chunk,
     texture_manager: &terrain_util::TextureManager,
-    materials: &RenderMaterials,
-) {
-    if let Some(mesh) = terrain_util::create_chunk_mesh(chunk, texture_manager) {
-        let material = materials
-            .chunk_material
-            .clone()
-            .expect("Chunk material is loaded");
-
-        let meshes: &mut Mut<Assets<Mesh>> = &mut ResMut::reborrow(meshes);
-        commands.spawn((
-            Mesh3d(meshes.add(mesh)),
-            Transform::from_xyz(
-                chunk.position.x * CHUNK_SIZE as f32,
-                chunk.position.y * CHUNK_SIZE as f32,
-                chunk.position.z * CHUNK_SIZE as f32,
-            ),
-            MeshMaterial3d(material),
-            player_components::Raycastable,
-            terrain_components::ChunkMesh {
-                key: [
-                    chunk.position.x as i32,
-                    chunk.position.y as i32,
-                    chunk.position.z as i32,
-                ],
-            },
-            Name::from("Transparent Chunk Mesh"),
-        ));
-    }
+) -> MeshTask {
+    let task_pool = AsyncComputeTaskPool::get();
+
+    let chunk = *chunk;
+    let texture_manager = texture_manager.clone();
+
+    let task =
+        task_pool.spawn(async move { terrain_util::create_chunk_mesh(&chunk, &texture_manager) });
+
+    MeshTask(task)
 }
 
-fn add_cross_objects(
-    commands: &mut Commands,
+fn create_cross_mesher_task(
     chunk: &Chunk,
-    materials: &RenderMaterials,
     texture_manager: &terrain_util::TextureManager,
-    meshes: &mut ResMut<Assets<Mesh>>,
+) -> MeshTask {
+    let task_pool = AsyncComputeTaskPool::get();
+
+    let chunk = *chunk;
+    let texture_manager = texture_manager.clone();
+
+    let task = task_pool
+        .spawn(async move { terrain_util::create_cross_mesh_for_chunk(&chunk, &texture_manager) });
+
+    MeshTask(task)
+}
+
+pub fn handle_chunk_tasks_system(
+    mut commands: Commands,
+    materials: Res<RenderMaterials>,
+    mut tasks: ResMut<MesherTasks>,
+    mut meshes: ResMut<Assets<Mesh>>,
 ) {
-    if let Some(mesh) = create_cross_mesh_for_chunk(chunk, texture_manager) {
-        let mesh_handle = meshes.add(mesh);
-
-        commands.spawn((
-            Mesh3d(mesh_handle),
-            MeshMaterial3d(
-                materials
-                    .transparent_material
-                    .clone()
-                    .expect("Transparent material exists"),
-            ),
-            Transform::from_xyz(
-                chunk.position.x * CHUNK_SIZE as f32,
-                chunk.position.y * CHUNK_SIZE as f32,
-                chunk.position.z * CHUNK_SIZE as f32,
-            ),
-            terrain_components::ChunkMesh {
-                key: [
-                    chunk.position.x as i32,
-                    chunk.position.y as i32,
-                    chunk.position.z as i32,
-                ],
-            },
-        ));
-    }
+    let mut next_poll_indicies: Vec<usize> = Vec::new();
+    tasks
+        .task_list
+        .iter_mut()
+        .enumerate()
+        .for_each(|(index, future_chunk)| {
+            let chunk_position = future_chunk.position;
+            let task_result =
+                bevy::tasks::block_on(future::poll_once(&mut future_chunk.mesh_task.0));
+            if task_result.is_none() {
+                // Check next poll
+                next_poll_indicies.push(index);
+                return;
+            }
+            let mesh_option = task_result.unwrap();
+            if mesh_option.is_none() {
+                return;
+            }
+            let mesh = mesh_option.expect("Mesh exists");
+            let mesh_handle = meshes.add(mesh);
+
+            let material_handle = match future_chunk.mesh_type {
+                MeshType::Solid => materials.chunk_material.clone(),
+                MeshType::Transparent => materials.transparent_material.clone(),
+            };
+
+            commands.spawn((
+                Mesh3d(mesh_handle),
+                MeshMaterial3d(material_handle.expect("Material exists")),
+                Transform::from_xyz(
+                    chunk_position.x * CHUNK_SIZE as f32,
+                    chunk_position.y * CHUNK_SIZE as f32,
+                    chunk_position.z * CHUNK_SIZE as f32,
+                ),
+                terrain_components::ChunkMesh {
+                    key: [
+                        chunk_position.x as i32,
+                        chunk_position.y as i32,
+                        chunk_position.z as i32,
+                    ],
+                },
+            ));
+        });
+
+    let mut index = 0;
+    tasks.task_list.retain(|_| {
+        let contains = next_poll_indicies.contains(&index);
+        index += 1;
+        contains
+    })
 }
 
 fn create_transparent_material(texture_handle: Handle<Image>) -> StandardMaterial {

src/client/terrain/util/blocks.rs

@@ -87,7 +87,7 @@ pub mod client_block {
 use client_block::block_properties;
 use TextureName::*;
 
-#[derive(Resource)]
+#[derive(Resource, Clone)]
 pub struct TextureManager {
     textures: HashMap<TextureName, TextureUV>,
 }