我目前正在開發一個基于 3D 體素的游戲，我希望根據玩家的運動來生成程式塊。
但是在一個簡單的系統中運行塊生成會導致巨大的 FPS 下降。
我已經嘗試創建一個任務池，該任務池運行獨立于其他所有內容std::sync::mpsc::channel，以生成塊資料和網格，然后由正常的 bevy 系統請求，緩沖然后使用commands.spawn(PbrBundle{...}).
fn chunk_loader(
pool: Res<Pool>,
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
mut chunkmap: ResMut<ChunkMap>,
mut buffer: ResMut<Buffer>, // buffer of chunk data
) {
let mut chunks = pool.request_chunks();
buffer.0.append(&mut chunks);
for _ in 0..CHUNK_UPDATES_PER_FRAME {
if let Some( (chunk, mesh) ) = buffer.0.pop() {
chunkmap.map.insert([chunk.x, chunk.y, chunk.z], chunk);
let mesh = mesh.clone();
commands.spawn_bundle(PbrBundle {
mesh: meshes.add(mesh),
transform: Transform::from_matrix(Mat4::from_scale_rotation_translation(
Vec3::splat(1.0),
Quat::from_rotation_x(0.0),
Vec3::new((chunk.x * CHUNK_SIZE as i64) as f32, (chunk.y * CHUNK_SIZE as i64) as f32, (chunk.z * CHUNK_SIZE as i64) as f32),
)),
material: materials.add(StandardMaterial {
base_color: Color::hex("993939").unwrap(),
perceptual_roughness: 0.95,
..default()
}),
..default()
}).insert(super::LoadedChunk{x: chunk.x, y: chunk.y, z: chunk.z, should_unload: false});
}
}
}
但這無濟于事，因為它仍然占用太多時間。
我需要的是一種以異步方式執行塊生成和生成的方法，這不會影響幀速率，但我不知道應該如何處理。
bevy::prelude::AsyncComputeTaskPool可能會完成這項作業，但我找不到任何檔案或示例，所以我不知道它到底做了什么，除了異步并行迭代查詢。
我從來沒有寫過任何異步代碼，有人可以幫助我嗎？
編輯
我發現上面的系統實際上運行得很好。
問題是我用來檢查的系統，要加載哪些塊。我使用 aHashMap來存盤每個塊，并且每次玩家移動時，我都會測驗多個塊是否已經生成，如果沒有則向任務池發送請求以執行此操作。
fn chunk_generation(
mut query: Query<(&Transform, &mut Player)>,
mut chunks: ResMut<ChunkMap>,
pool: Res<Pool>,
) {
let mut player_pos = Vec3::ZERO;
let mut player_moved: bool = false;
for (transform, mut player) in query.iter_mut().next() {
player_pos = transform.translation;
if player.chunks_moved_since_update > 0 {
player_moved = true;
player.chunks_moved_since_update = 0;
}
}
let chunk_x = (player_pos.x / CHUNK_SIZE as f32).round() as i64;
let chunk_y = (player_pos.y / CHUNK_SIZE as f32).round() as i64;
let chunk_z = (player_pos.z / CHUNK_SIZE as f32).round() as i64;
// loading
if player_moved {
let mut chunks_to_load: Vec<[i64; 3]> = Vec::new();
for x in -RENDER_DISTANCE_HOR..RENDER_DISTANCE_HOR {
for y in -RENDER_DISTANCE_VER..RENDER_DISTANCE_VER {
for z in -RENDER_DISTANCE_HOR..RENDER_DISTANCE_HOR {
let chunk_x = chunk_x as i64 x;
let chunk_y = chunk_y as i64 y;
let chunk_z = chunk_z as i64 z;
let chunk_coords = [chunk_x, chunk_y, chunk_z];
// check if chunk is not in world
if !chunks.map.contains_key(&chunk_coords) {
println!("generating new chunk");
let chunk = Chunk::new(chunk_x, chunk_y, chunk_z);
chunks.map.insert(chunk_coords, chunk);
chunks_to_load.push([chunk_x, chunk_y, chunk_z]);
}
}
}
}
pool.send_chunks(chunks_to_load);
}
}
是否也可以使這個異步？
uj5u.com熱心網友回復：
bevy::tasks::AsyncComputeTaskPoolwrappend inbevy::tasks::Task是我正在尋找的方法。
我現在有一個系統，可以將任務插入每個塊以生成自身，然后在另一個函式中輪詢該任務，如下所示：
#[derive(Component)]
pub struct GenTask {
pub task: Task<Vec<([i64; 3], ChunkData)>>
}
pub fn prepare_gen_tasks(
mut queue: ResMut<ChunkGenQueue>,
chunks: Res<ChunkMap>,
pool: Res<AsyncComputeTaskPool>,
mut cmds: Commands,
) {
while let Some(key) = queue.queue.pop() {
if let Some(entity) = chunks.entity(key) {
let task = pool.spawn(async move {
let chunk = Chunk::new(key);
super::generation::generate(chunk)
});
cmds.entity(entity).insert(GenTask{task});
}
}
}
pub fn apply_gen_tasks(
mut voxels: ResMut<VoxelMap>,
mut query: Query<(Entity, &mut GenTask)>,
mut mesh_queue: ResMut<ChunkMeshQueue>,
mut cmds: Commands,
) {
query.for_each_mut(|(entity, mut gen_task)| {
if let Some(chunks) = future::block_on(future::poll_once(&mut gen_task.task)) {
for (key, data) in chunks.iter() {
voxels.map.insert(*key, *data);
mesh_queue.queue.push(*key);
}
cmds.entity(entity).remove::<GenTask>();
}
return;
});
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/448918.html