improved major bottleneck, perf on larger worlds went from 50fps to full vsync fps (144)

Author: syntaxerror-9

src/macros.rs

@@ -1,6 +1,7 @@
 #[macro_export]
 macro_rules! perf {
-    ($start:expr, $end:expr, $fn_name:expr) => {
-        println!("PERF: {} - {}", $fn_name, ($end - $start).as_secs_f64())
+    ($start:expr, $fn_name:expr) => {
+        let end = Instant::now();
+        println!("PERF: {} - {}", $fn_name, (end - $start).as_secs_f64())
     };
 }

src/state.rs

@@ -1,9 +1,11 @@
 use std::sync::{Mutex, RwLock};
+use std::time::Instant;
 use std::{f32::consts, sync::Arc};
 
 use crate::blocks::block::Block;
 use crate::blocks::block_type::BlockType;
 use crate::collision::CollisionBox;
+use crate::perf;
 use crate::persistence::Saveable;
 use crate::pipeline::{Pipeline, PipelineTrait};
 use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
@@ -246,6 +248,7 @@ impl State {
     pub fn update(&mut self, delta_time: f32, total_time: f32) {
         let mut collisions = vec![];
 
+        let start_update = Instant::now();
         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();
@@ -315,7 +318,7 @@ impl State {
         let chunks = self
             .world
             .chunks
-            .iter()
+            .values()
             .map(|f| f.read().unwrap())
             .collect::<Vec<_>>();
 

src/world.rs

@@ -1,4 +1,6 @@
 use glam::Vec3;
+use std::borrow::Borrow;
+use std::collections::HashMap;
 use std::fs::File;
 use std::ops::{Deref, DerefMut};
 use std::sync::{Mutex, RwLock};
@@ -22,7 +24,7 @@ pub const FREQUENCY: f32 = 1. / 128.;
 pub const NOISE_CHUNK_PER_ROW: u32 = NOISE_SIZE / CHUNK_SIZE;
 pub const MAX_TREES_PER_CHUNK: u32 = 3;
 
-pub const CHUNKS_PER_ROW: u32 = 9;
+pub const CHUNKS_PER_ROW: u32 = 25;
 pub const CHUNKS_REGION: u32 = CHUNKS_PER_ROW * CHUNKS_PER_ROW;
 pub const WATER_HEIGHT_LEVEL: u8 = 5;
 
@@ -40,7 +42,7 @@ pub type NoiseData = Vec<f32>;
 
 pub type WorldChunk = Arc<RwLock<Chunk>>;
 pub struct World {
-    pub chunks: Vec<WorldChunk>,
+    pub chunks: HashMap<(i32, i32), WorldChunk>,
     pub thread_pool: Option<ThreadPool>,
     pub seed: u32,
     pub noise_data: Arc<NoiseData>,
@@ -50,24 +52,9 @@ pub struct World {
 }
 
 impl World {
-    // gets all the chunks except the one passed in the index
-    pub fn get_other_chunks_by_index(&self, chunk_index: usize) -> Vec<WorldChunk> {
-        self.chunks
-            .iter()
-            .enumerate()
-            .filter_map(|(i, c)| {
-                return if i != chunk_index {
-                    Some(c.clone())
-                } else {
-                    None
-                };
-            })
-            .collect()
-    }
-    // gets all the chunks except the one passed
     pub fn get_other_chunks(&self, chunk_ptr: WorldChunk) -> Vec<WorldChunk> {
         self.chunks
-            .iter()
+            .values()
             .filter_map(|c| {
                 return if !Arc::ptr_eq(&chunk_ptr, c) {
                     Some(c.clone())
@@ -78,89 +65,55 @@ impl World {
             .collect()
     }
     pub fn place_block(&mut self, block: Arc<RwLock<Block>>) {
-        let mut chunks_to_rerender = vec![];
-
         let block_borrow = block.read().unwrap();
-        let chunk_coords = block_borrow.get_chunk_coords();
+        let mut chunks_to_rerender = vec![block_borrow.get_chunk_coords()];
         let chunk = self
             .chunks
-            .iter()
-            .find(|c| {
-                let c = c.read().unwrap();
-                c.x == chunk_coords.0 && c.y == chunk_coords.1
-            })
+            .get(&chunks_to_rerender[0])
             .expect("Cannot delete a block from unloaded chunk");
 
-        chunks_to_rerender.push(chunk.clone());
         let mut chunk_lock = chunk.write().unwrap();
         chunk_lock.add_block(block.clone(), true);
 
         let block_borrow = block.read().unwrap();
-        let block_neighbour_chunks = block_borrow.get_neighbour_chunks_coords();
+        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
         std::mem::drop(chunk_lock);
 
-        if block_neighbour_chunks.len() > 0 {
-            for neighbour_chunk in block_neighbour_chunks {
-                let neighbour_chunk = self
-                    .chunks
-                    .iter()
-                    .find(|o| {
-                        let c = o.read().unwrap();
-                        return c.x == neighbour_chunk.0 && c.y == neighbour_chunk.1;
-                    })
-                    .expect("Cannot destroy a block without neighbour being loaded");
-
-                chunks_to_rerender.push(neighbour_chunk.clone());
-            }
-        }
+        // if block_neighbour_chunks.len() > 0 {
+        //     for neighbour_chunk in block_neighbour_chunks {
+        //         let neighbour_chunk = self
+        //             .chunks
+        //             .get(&neighbour_chunk)
+        //             .expect("Cannot destroy a block without neighbour being loaded");
+
+        //         chunks_to_rerender.push(neighbour_chunk.clone());
+        //     }
+        // }
 
-        self.render_chunks(&chunks_to_rerender);
+        self.render_chunks(chunks_to_rerender)
+        // self.render_chunks(block_neighbour_chunks.append(&mut vec![chunk_coords]));
     }
     pub fn remove_block(&mut self, block: Arc<RwLock<Block>>) {
-        let mut chunks_to_rerender = vec![];
-
         let block_borrow = block.read().unwrap();
-        let chunk_coords = block_borrow.get_chunk_coords();
+        let mut chunks_to_rerender = vec![block_borrow.get_chunk_coords()];
         let chunk = self
             .chunks
-            .iter()
-            .find(|c| {
-                let c = c.read().unwrap();
-                c.x == chunk_coords.0 && c.y == chunk_coords.1
-            })
+            .get(&chunks_to_rerender[0])
             .expect("Cannot delete a block from unloaded chunk");
 
         let mut chunk_lock = chunk.write().unwrap();
         chunk_lock.remove_block(&(block_borrow.position));
-        chunks_to_rerender.push(chunk.clone());
         // chunk_lock.build_mesh(self.get_other_chunks(chunk.clone()));
-        let block_neighbour_chunks = block_borrow.get_neighbour_chunks_coords();
+        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
         // I hate this so much
         std::mem::drop(chunk_lock);
 
-        if block_neighbour_chunks.len() > 0 {
-            for neighbour_chunk in block_neighbour_chunks {
-                let neighbour_chunk = self
-                    .chunks
-                    .iter()
-                    .find(|o| {
-                        let c = o.read().unwrap();
-                        c.x == neighbour_chunk.0 && c.y == neighbour_chunk.1
-                    })
-                    .expect("Cannot destroy a block without neighbour being loaded");
-
-                chunks_to_rerender.push(neighbour_chunk.clone());
-            }
-        }
-        self.render_chunks(&chunks_to_rerender);
+        self.render_chunks(chunks_to_rerender);
     }
     pub fn get_blocks_absolute(&self, position: &Vec3) -> Option<Arc<RwLock<Block>>> {
         let (chunk_x, chunk_y) = position.get_chunk_from_position_absolute();
 
-        let chunk = self.chunks.iter().find(|c| {
-            let c = c.read().unwrap();
-            c.x == chunk_x && c.y == chunk_y
-        })?;
+        let chunk = self.chunks.get(&(chunk_x, chunk_y))?;
         let chunk = chunk.read().unwrap();
 
         let relative_position = position.relative_from_absolute();
@@ -252,20 +205,20 @@ impl World {
                 })
                 .collect();
 
-            let mut indices_to_remove: Vec<usize> = vec![];
-            for (i, chunk) in self.chunks.iter().enumerate() {
-                let chunk = chunk.read().unwrap();
-                if (delta.1 != 0 && chunk.y == chunk_y_remove)
-                    || (delta.0 != 0 && chunk.x == chunk_x_remove)
+            let mut keys_to_remove = vec![];
+            for key in self.chunks.keys() {
+                // let chunk = chunk.read().unwrap();
+                if (delta.1 != 0 && key.1 == chunk_y_remove)
+                    || (delta.0 != 0 && key.0 == chunk_x_remove)
                 {
-                    indices_to_remove.push(i);
+                    keys_to_remove.push(key.clone());
                 }
             }
 
             // Save the unloaded chunks
             let (sender, receiver) = mpsc::channel();
-            for (o, index) in indices_to_remove.iter().enumerate() {
-                let chunk = self.chunks.remove(index - o);
+            for key in keys_to_remove.iter() {
+                let chunk = self.chunks.remove(key).expect("Something went wrong");
                 let sender = sender.clone();
                 self.thread_pool.as_ref().unwrap().execute(move || {
                     let chunk = chunk.write().unwrap();
@@ -276,7 +229,7 @@ impl World {
                 })
             }
 
-            for _ in indices_to_remove.iter() {
+            for _ in keys_to_remove.iter() {
                 receiver.recv().unwrap();
             }
 
@@ -306,19 +259,20 @@ impl World {
 
             for _ in 0..chunks_added {
                 let chunk = receiver.recv().unwrap();
-                self.chunks.push(Arc::new(RwLock::new(chunk)));
+                self.chunks
+                    .insert((chunk.x, chunk.y), Arc::new(RwLock::new(chunk)));
             }
             self.handle_outside_blocks();
-            self.render_chunks(&self.chunks[self.chunks.len() - chunks_added..]);
             // Re-render only the last inserted chunks
+            self.render_chunks(new_chunks_positions);
         }
 
         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() {
+            for chunk in self.chunks.values() {
                 let chunk = Arc::clone(&chunk);
                 let sender = sender.clone();
                 let player = Arc::clone(&player);
@@ -338,7 +292,7 @@ impl World {
     }
 
     pub fn save_state(&self) {
-        for chunk in self.chunks.iter() {
+        for chunk in self.chunks.values() {
             let chunkbrw = chunk.read().unwrap();
             if chunkbrw.modified {
                 chunkbrw.save().expect("failed to save");
@@ -349,7 +303,6 @@ impl World {
         let (sender, receiver) = mpsc::channel();
         let player = player.read().unwrap();
 
-        let mut chunks = vec![];
         for chunk_x in LB + player.current_chunk.0..=UB + player.current_chunk.0 {
             for chunk_y in LB + player.current_chunk.1..=UB + player.current_chunk.1 {
                 let sender = sender.clone();
@@ -373,30 +326,36 @@ impl World {
 
         for _ in 0..CHUNKS_PER_ROW * CHUNKS_PER_ROW {
             let chunk = receiver.recv().expect("Some chunks are missing");
-            chunks.push(Arc::new(RwLock::new(chunk)));
+            self.chunks
+                .insert((chunk.x, chunk.y), Arc::new(RwLock::new(chunk)));
         }
-        self.chunks.append(&mut chunks); // Add chunks to self
 
         self.handle_outside_blocks();
-        self.render_chunks(&self.chunks);
+        // this is kinda slow
+        self.render_chunks(self.chunks.keys().collect::<Vec<_>>());
     }
     // chunks: slice containing the chunk to re-render
-    fn render_chunks(&self, chunks: &[WorldChunk]) {
+    fn render_chunks<I>(&self, chunk_keys: Vec<I>)
+    where
+        I: Borrow<(i32, i32)>,
+    {
         let (sender, receiver) = mpsc::channel();
 
-        for chunk in chunks.iter() {
-            let sender = sender.clone();
-            let other = self.get_other_chunks(chunk.clone());
-            let chunk = chunk.clone();
-
-            self.thread_pool.as_ref().unwrap().execute(move || {
-                let chunk_ptr = chunk.clone();
-                let chunk = chunk.read().unwrap();
-                let res = chunk.build_mesh(other);
-                sender.send((res, chunk_ptr)).unwrap();
-            });
+        for key in chunk_keys.iter() {
+            if let Some(chunk) = self.chunks.get(key.borrow()) {
+                let sender = sender.clone();
+                let other = self.get_other_chunks(chunk.clone());
+                let chunk = chunk.clone();
+
+                self.thread_pool.as_ref().unwrap().execute(move || {
+                    let chunk_ptr = chunk.clone();
+                    let chunk = chunk.read().unwrap();
+                    let res = chunk.build_mesh(other);
+                    sender.send((res, chunk_ptr)).unwrap();
+                });
+            }
         }
-        for _ in chunks.iter() {
+        for _ in chunk_keys.iter() {
             let (
                 (
                     indices,
@@ -419,7 +378,7 @@ impl World {
     }
     fn handle_outside_blocks(&mut self) {
         let mut blocks_to_add = vec![];
-        for chunk in self.chunks.iter() {
+        for chunk in self.chunks.values() {
             let mut chunkbrw = chunk.write().unwrap();
             blocks_to_add.append(&mut chunkbrw.outside_blocks);
         }
@@ -428,10 +387,7 @@ impl World {
 
         for block in blocks_to_add.iter() {
             let chunk_coords = block.read().unwrap().get_chunk_coords();
-            if let Some(chunkptr) = self.chunks.iter().find(|c| {
-                let c = c.read().unwrap();
-                c.x == chunk_coords.0 && c.y == chunk_coords.1
-            }) {
+            if let Some(chunkptr) = self.chunks.get(&chunk_coords) {
                 let mut chunkbrw = chunkptr.write().unwrap();
                 chunkbrw.add_block(block.clone(), false);
                 if let None = chunks_to_rerender.iter().find(|c| Arc::ptr_eq(c, chunkptr)) {
@@ -453,7 +409,7 @@ impl World {
 
         World {
             chunk_data_layout,
-            chunks: vec![],
+            chunks: HashMap::new(),
             noise_data,
             device,
             queue,