feat: multithread view frustum culling

Author: syntaxerror-9

src/chunk.rs

@@ -35,6 +35,7 @@ pub struct Chunk {
     pub chunk_index_buffer: Option<wgpu::Buffer>,
     pub chunk_vertex_buffer: Option<wgpu::Buffer>,
     pub outside_blocks: Vec<Arc<RwLock<Block>>>,
+    pub visible: bool,
 }
 
 impl Chunk {
@@ -322,7 +323,8 @@ impl Chunk {
     }
     // https://www.lighthouse3d.com/tutorials/view-frustum-culling/
     // Note: we don't compute the top and bottom planes, only far,near,right,left
-    pub fn is_visible(&self, player: &Player) -> bool {
+    pub fn is_visible(&self, player: Arc<RwLock<Player>>) -> bool {
+        let player = player.read().unwrap();
         let forward = player.camera.get_forward_dir();
         let right = player.camera.get_right_dir();
         let halfvside = player.camera.zfar / f32::tan(player.camera.fovy / 2.0);
@@ -423,6 +425,7 @@ impl Chunk {
             chunk_position_buffer,
             indices: 0,
             outside_blocks: vec![],
+            visible: true,
         };
 
         if !was_loaded {

src/pipeline.rs

@@ -47,8 +47,8 @@ impl Pipeline {
                 label: None,
                 source: wgpu::ShaderSource::Wgsl(shader_source.into()),
             });
-
-        let uniforms = Uniforms::from(&state.player.camera);
+        let camera = &state.player.read().unwrap().camera;
+        let uniforms = Uniforms::from(camera);
 
         let projection_buffer =
             state

src/player.rs

@@ -49,11 +49,6 @@ impl Player {
     // Position relative to the chunk
     pub fn to_relative_position(&self) -> glam::Vec3 {
         todo!();
-        // glam::vec3(
-        //     f32::abs(self.camera.eye.x + (CHUNK_SIZE as f32 - 1.0) % CHUNK_SIZE as f32),
-        //     self.camera.eye.y,
-        //     f32::abs(self.camera.eye.z + (CHUNK_SIZE as f32 - 1.0) % CHUNK_SIZE as f32),
-        // )
     }
     pub fn get_collision(&self) -> crate::collision::CollisionBox {
         crate::collision::CollisionBox::new(
@@ -229,16 +224,16 @@ pub struct Camera {
 
 impl Camera {
     pub fn new(surface_width: f32, surface_height: f32) -> Camera {
-        let eye = if let Ok(eye) = Camera::load(Box::new(())) {
-            eye
+        let (eye, yaw, pitch) = if let Ok((eye, yaw, pitch)) = Camera::load(Box::new(())) {
+            (eye, yaw, pitch)
         } else {
-            glam::vec3(-4.0, 50.0, 4.0)
+            (glam::vec3(-4.0, 50.0, 4.0), consts::FRAC_PI_2, 0.0)
         };
         Self {
             aspect_ratio: surface_width / surface_height,
             eye,
-            yaw: consts::FRAC_PI_2,
-            pitch: 0.0,
+            yaw,
+            pitch,
 
             fovy: consts::FRAC_PI_4,
             znear: 0.1,
@@ -280,7 +275,10 @@ impl Saveable<glam::Vec3> for Camera {
         if let Ok(_) = std::fs::create_dir("data") {
             println!("Created dir");
         }
-        let data = format!("{},{},{}", self.eye.x, self.eye.y, self.eye.z);
+        let data = format!(
+            "{},{},{},{},{}",
+            self.eye.x, self.eye.y, self.eye.z, self.yaw, self.pitch
+        );
 
         let player_file_name = "data/player";
         std::fs::write(player_file_name, data.as_bytes())?;
@@ -289,14 +287,16 @@ impl Saveable<glam::Vec3> for Camera {
     }
 }
 
-impl Loadable<glam::Vec3> for Camera {
-    fn load(_: Box<dyn Any>) -> Result<Vec3, Box<dyn Error>> {
+impl Loadable<(glam::Vec3, f32, f32)> for Camera {
+    fn load(_: Box<dyn Any>) -> Result<((Vec3, f32, f32)), Box<dyn Error>> {
         let data = String::from_utf8(std::fs::read("data/player")?)?;
         let mut data = data.split(",");
         let x = data.next().unwrap().parse::<f32>().unwrap();
         let y = data.next().unwrap().parse::<f32>().unwrap();
         let z = data.next().unwrap().parse::<f32>().unwrap();
+        let yaw = data.next().unwrap().parse::<f32>().unwrap();
+        let pitch = data.next().unwrap().parse::<f32>().unwrap();
 
-        return Ok(glam::vec3(x, y, z));
+        return Ok((glam::vec3(x, y, z), yaw, pitch));
     }
 }

src/state.rs

@@ -67,7 +67,7 @@ impl State {
         };
 
         let camera = Camera::new(surface_config.width as f32, surface_config.height as f32);
-        let player = Player {
+        let player = Arc::new(RwLock::new(Player {
             camera,
             current_chunk: (0, 0),
             is_jumping: false,
@@ -76,7 +76,7 @@ impl State {
             facing_face: None,
             jump_action_start: None,
             is_ghost: false,
-        };
+        }));
 
         surface.configure(&device, &surface_config);
         let config = Config {
@@ -113,16 +113,21 @@ impl State {
     }
     pub fn save_state(&mut self) {
         self.player
+            .read()
+            .unwrap()
             .camera
             .save()
             .expect("Failed to save camera state");
         self.world.save_state();
     }
     pub fn dispose(&mut self) {
         self.world.dispose();
+        self.device.destroy();
+        std::mem::drop(self.queue.to_owned());
     }
     pub fn handle_keypress(&mut self, event: KeyEvent, delta_time: f32) {
         let is_pressed: f32 = if event.state.is_pressed() { 1. } else { 0. };
+        let mut player = self.player.write().unwrap();
 
         match event {
             KeyEvent {
@@ -163,17 +168,17 @@ impl State {
                 state: winit::event::ElementState::Pressed,
                 ..
             } => {
-                if self.player.on_ground {
-                    self.player.is_jumping = true;
-                    self.player.jump_action_start = Some(std::time::Instant::now());
+                if player.on_ground {
+                    player.is_jumping = true;
+                    player.jump_action_start = Some(std::time::Instant::now());
                 }
             }
             KeyEvent {
                 physical_key: PhysicalKey::Code(KeyCode::KeyG),
                 state: winit::event::ElementState::Pressed,
                 ..
             } => {
-                self.player.is_ghost = !self.player.is_ghost;
+                player.is_ghost = !player.is_ghost;
             }
             KeyEvent {
                 physical_key: PhysicalKey::Code(KeyCode::KeyF),
@@ -190,9 +195,9 @@ impl State {
         }
     }
     pub fn on_click(&mut self, button: MouseButton) {
-        if let Some(facing_block) = self.player.facing_block.as_ref() {
-            let facing_face = self
-                .player
+        let player = self.player.read().unwrap();
+        if let Some(facing_block) = player.facing_block.as_ref() {
+            let facing_face = player
                 .facing_face
                 .expect("Cannot be not facing a face if it's facing a block");
             match button {
@@ -217,7 +222,7 @@ impl State {
         }
     }
     pub fn handle_mouse(&mut self, delta: &glam::Vec2) {
-        self.player.camera.move_target(delta)
+        self.player.write().unwrap().camera.move_target(delta)
     }
 
     pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
@@ -231,7 +236,8 @@ impl State {
     }
     pub fn update(&mut self, delta_time: f32, total_time: f32) {
         let mut collisions = vec![];
-        if let Some(nearby_blocks) = self.world.get_blocks_nearby(&self.player) {
+
+        if let Some(nearby_blocks) = self.world.get_blocks_nearby(Arc::clone(&self.player)) {
             for block in nearby_blocks.iter() {
                 let block = block.read().unwrap();
                 let collision = CollisionBox::from_block_position(
@@ -242,22 +248,23 @@ impl State {
                 collisions.push(collision);
             }
         };
-        self.player.move_camera(
+        let mut player = self.player.write().unwrap();
+        player.move_camera(
             &self.camera_controller.movement_vector,
             delta_time,
             &collisions,
         );
-        if let Some((block, face_dir)) = self.player.get_facing_block(&collisions) {
+        if let Some((block, face_dir)) = player.get_facing_block(&collisions) {
             let block = self.world.get_blocks_absolute(&block.to_block_position());
 
-            self.player.facing_block = block;
-            self.player.facing_face = Some(face_dir);
+            player.facing_block = block;
+            player.facing_face = Some(face_dir);
         } else {
-            self.player.facing_block = None;
-            self.player.facing_face = None;
+            player.facing_block = None;
+            player.facing_face = None;
         }
 
-        let uniforms = Uniforms::from(&self.player.camera);
+        let uniforms = Uniforms::from(&player.camera);
 
         for pipeline in self.pipelines.iter() {
             self.queue.write_buffer(
@@ -266,14 +273,16 @@ impl State {
                 bytemuck::cast_slice(&[uniforms.view]),
             )
         }
+        // Drop write lock
+        std::mem::drop(player);
 
         self.world.update(
-            &mut self.player,
+            Arc::clone(&self.player),
             Arc::clone(&self.queue),
             Arc::clone(&self.device),
         );
         self.ui.update(
-            &mut self.player,
+            Arc::clone(&self.player),
             Arc::clone(&self.queue),
             Arc::clone(&self.device),
         );
@@ -335,7 +344,7 @@ impl State {
             rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
 
             for chunk in chunks.iter() {
-                if chunk.is_visible(&self.player) {
+                if chunk.visible {
                     rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);
                     rpass.set_vertex_buffer(
                         0,
@@ -410,10 +419,9 @@ pub struct State {
     pub window: Arc<Mutex<Window>>,
     pub surface_config: wgpu::SurfaceConfiguration,
     pub pipelines: Vec<Box<dyn PipelineTrait>>,
-    pub player: Player,
+    pub player: Arc<RwLock<Player>>,
     pub world: World,
     pub ui: UI,
     pub config: Config,
     pub camera_controller: CameraController,
-    // pub model: Rc<RefCell<Model>>,
 }

src/ui.rs

@@ -4,7 +4,7 @@ use crate::pipeline::{PipelineTrait, PipelineType, Uniforms};
 use crate::player::Player;
 use crate::state::State;
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex, RwLock};
 use wgpu::util::DeviceExt;
 use wgpu::{BindGroup, Buffer, RenderPipeline};
 
@@ -41,7 +41,13 @@ impl UI {
             index_buffer,
         }
     }
-    pub fn update(&mut self, player: &Player, queue: Arc<wgpu::Queue>, device: Arc<wgpu::Device>) {
+    pub fn update(
+        &mut self,
+        player: Arc<RwLock<Player>>,
+        queue: Arc<wgpu::Queue>,
+        device: Arc<wgpu::Device>,
+    ) {
+        let player = player.read().unwrap();
         if let Some(block_ptr) = player.facing_block.as_ref() {
             let block = block_ptr.read().unwrap();
 
@@ -115,7 +121,7 @@ impl UIPipeline {
                 source: wgpu::ShaderSource::Wgsl(shader_source.into()),
             });
 
-        let uniforms = Uniforms::from(&state.player.camera);
+        let uniforms = Uniforms::from(&state.player.read().unwrap().camera);
 
         let projection_buffer =
             state

src/world.rs

@@ -1,6 +1,6 @@
 use glam::Vec3;
 use std::ops::{Deref, DerefMut};
-use std::sync::RwLock;
+use std::sync::{Mutex, RwLock};
 use std::{
     sync::{mpsc, Arc},
     thread,
@@ -163,7 +163,11 @@ impl World {
 
         return Some(block);
     }
-    pub fn get_blocks_nearby(&self, player: &Player) -> Option<Vec<Arc<RwLock<Block>>>> {
+    pub fn get_blocks_nearby(
+        &self,
+        player: Arc<RwLock<Player>>,
+    ) -> Option<Vec<Arc<RwLock<Block>>>> {
+        let player = player.read().unwrap();
         let mut positions = vec![];
         let mut nearby_blocks = vec![];
 
@@ -185,15 +189,18 @@ impl World {
     }
     pub fn update(
         &mut self,
-        player: &mut Player,
+        player: Arc<RwLock<Player>>,
         queue: Arc<wgpu::Queue>,
         device: Arc<wgpu::Device>,
     ) {
-        let current_chunk = player.calc_current_chunk();
-        if current_chunk != player.current_chunk {
+        let mut player_write = player.write().unwrap();
+        let current_chunk = player_write.calc_current_chunk();
+
+        // Update loaded chunks based on player position
+        if current_chunk != player_write.current_chunk {
             let delta = (
-                current_chunk.0 - player.current_chunk.0,
-                current_chunk.1 - player.current_chunk.1,
+                current_chunk.0 - player_write.current_chunk.0,
+                current_chunk.1 - player_write.current_chunk.1,
             );
 
             let o = if CHUNKS_PER_ROW % 2 == 0 { 1 } else { 0 };
@@ -212,8 +219,8 @@ impl World {
 
             let mut new_chunks_positions: Vec<(i32, i32)> = vec![];
 
-            let chunk_y_remove = player.current_chunk.1 + old_chunks_offset;
-            let chunk_x_remove = player.current_chunk.0 + old_chunks_offset;
+            let chunk_y_remove = player_write.current_chunk.1 + old_chunks_offset;
+            let chunk_x_remove = player_write.current_chunk.0 + old_chunks_offset;
             if delta.0 != 0 {
                 for i in LB + current_chunk.1..=UB + current_chunk.1 {
                     new_chunks_positions.push((current_chunk.0 + new_chunks_offset, i));
@@ -295,11 +302,30 @@ impl World {
             // Re-render only the last inserted chunks
         }
 
-        player.current_chunk = current_chunk;
+        player_write.current_chunk = current_chunk;
+        std::mem::drop(player_write);
+        // Update visible chunks based on player position and direction
+        {
+            let (sender, receiver) = mpsc::channel();
+            for chunk in self.chunks.iter() {
+                let chunk = Arc::clone(&chunk);
+                let sender = sender.clone();
+                let player = Arc::clone(&player);
+                self.thread_pool.as_ref().unwrap().execute(move || {
+                    let mut chunk = chunk.write().unwrap();
+                    chunk.visible = chunk.is_visible(player);
+                    sender.send(()).unwrap();
+                });
+            }
+            for _ in self.chunks.iter(){
+                receiver.recv().unwrap();
+            }
+        }
     }
     pub fn dispose(&mut self) {
         self.thread_pool = None;
     }
+
     pub fn save_state(&self) {
         for chunk in self.chunks.iter() {
             let chunkbrw = chunk.read().unwrap();