feat: changed mutex in favor of RwLock and everything is now pretty much multithreadable -- will need tho some major refactoring

Author: syntaxerror-9

Cargo.toml

@@ -28,3 +28,6 @@ features = ["png", "jpeg"]
 anyhow = "1.0"
 fs_extra = "1.2"
 glob = "0.3"
+
+[build]
+rustflags = ["-Z", "threads=8"]

src/blocks/block.rs

@@ -3,8 +3,9 @@ use bytemuck::{Pod, Zeroable};
 use super::block_type::BlockType;
 use crate::world::CHUNK_SIZE;
 use glam::Vec3;
-use std::sync::MutexGuard;
+use std::sync::{Arc, MutexGuard, RwLock};
 
+#[derive(Debug)]
 pub struct Block {
     pub position: glam::Vec3,
     pub absolute_position: glam::Vec3,
@@ -38,10 +39,7 @@ pub enum FaceDirections {
 }
 
 impl FaceDirections {
-    pub fn create_face_data(
-        &self,
-        block: &MutexGuard<'_, Block>,
-    ) -> (Vec<BlockVertexData>, Vec<u32>) {
+    pub fn create_face_data(&self, block: Arc<RwLock<Block>>) -> (Vec<BlockVertexData>, Vec<u32>) {
         let indices = self.get_indices();
 
         let mut unique_indices: Vec<u32> = Vec::with_capacity(4);
@@ -66,15 +64,16 @@ impl FaceDirections {
             *indices_map = index_of as u32;
         }
 
-        let face_texcoords = block.block_type.get_texcoords(*self);
+        let block_read = block.read().unwrap();
+        let face_texcoords = block_read.block_type.get_texcoords(*self);
         let normals = self.get_normal_vector();
 
         unique_indices.iter().enumerate().for_each(|(i, index)| {
             vertex_data.push(BlockVertexData {
                 position: [
-                    CUBE_VERTEX[(*index as usize * 3 + 0) as usize] + block.position.x,
-                    CUBE_VERTEX[(*index as usize * 3 + 1) as usize] + block.position.y,
-                    CUBE_VERTEX[(*index as usize * 3 + 2) as usize] + block.position.z,
+                    CUBE_VERTEX[(*index as usize * 3 + 0) as usize] + block_read.position.x,
+                    CUBE_VERTEX[(*index as usize * 3 + 1) as usize] + block_read.position.y,
+                    CUBE_VERTEX[(*index as usize * 3 + 2) as usize] + block_read.position.z,
                 ],
                 normal: normals.into(),
                 tex_coords: face_texcoords[i],
@@ -86,7 +85,7 @@ impl FaceDirections {
 
     pub fn create_face_data_abs(
         &self,
-        block: &MutexGuard<'_, Block>, // To prevent deadlocks
+        block: Arc<RwLock<Block>>,
     ) -> (Vec<BlockVertexData>, Vec<u32>) {
         let indices = self.get_indices();
 
@@ -112,15 +111,16 @@ impl FaceDirections {
             *indices_map = index_of as u32;
         }
 
-        let face_texcoords = block.block_type.get_texcoords(*self);
+        let block_read = block.read().unwrap();
+        let face_texcoords = block_read.block_type.get_texcoords(*self);
         let normals = self.get_normal_vector();
 
         unique_indices.iter().enumerate().for_each(|(i, index)| {
             vertex_data.push(BlockVertexData {
                 position: [
-                    CUBE_VERTEX[(*index as usize * 3 + 0) as usize] + block.absolute_position.x,
-                    CUBE_VERTEX[(*index as usize * 3 + 1) as usize] + block.absolute_position.y,
-                    CUBE_VERTEX[(*index as usize * 3 + 2) as usize] + block.absolute_position.z,
+                    CUBE_VERTEX[(*index as usize * 3 + 0) as usize] + block_read.absolute_position.x,
+                    CUBE_VERTEX[(*index as usize * 3 + 1) as usize] + block_read.absolute_position.y,
+                    CUBE_VERTEX[(*index as usize * 3 + 2) as usize] + block_read.absolute_position.z,
                 ],
                 normal: normals.into(),
                 tex_coords: face_texcoords[i],

src/chunk.rs

@@ -1,4 +1,5 @@
 use crate::persistance::{Loadable, Saveable};
+use crate::world::WorldChunk;
 use crate::{
     blocks::{
         block::{Block, BlockVertexData, FaceDirections},
@@ -10,12 +11,12 @@ use crate::{
 use glam::Vec3;
 use std::any::Any;
 use std::error::Error;
-use std::ptr::drop_in_place;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, RwLock};
 use wgpu::util::DeviceExt;
 
-pub type BlockVec = Vec<Vec<Option<Arc<Mutex<Block>>>>>;
+pub type BlockVec = Vec<Vec<Option<Arc<RwLock<Block>>>>>;
 
+#[derive(Debug)]
 pub struct Chunk {
     pub x: i32,
     pub y: i32,
@@ -28,12 +29,12 @@ pub struct Chunk {
     pub chunk_position_buffer: wgpu::Buffer,
     pub chunk_index_buffer: Option<wgpu::Buffer>,
     pub chunk_vertex_buffer: Option<wgpu::Buffer>,
-    pub outside_blocks: Vec<Arc<Mutex<Block>>>,
+    pub outside_blocks: Vec<Arc<RwLock<Block>>>,
 }
 
 impl Chunk {
-    pub fn add_block(&mut self, block: Arc<Mutex<Block>>) {
-        let block_borrow = block.lock().unwrap();
+    pub fn add_block(&mut self, block: Arc<RwLock<Block>>) {
+        let block_borrow = block.read().unwrap();
 
         let y_blocks = self
             .blocks
@@ -71,7 +72,7 @@ impl Chunk {
         }
         return false;
     }
-    pub fn get_block_at_relative(&self, position: &glam::Vec3) -> Option<Arc<Mutex<Block>>> {
+    pub fn get_block_at_relative(&self, position: &glam::Vec3) -> Option<Arc<RwLock<Block>>> {
         if let Some(y_blocks) = self
             .blocks
             .get(((position.x * CHUNK_SIZE as f32) + position.z) as usize)
@@ -100,16 +101,16 @@ impl Chunk {
             false
         }
     }
-    pub fn build_mesh(&mut self, other_chunks: Vec<Arc<Mutex<Chunk>>>) {
+    pub fn build_mesh(&self, other_chunks: Vec<WorldChunk>) -> (u32, wgpu::Buffer, wgpu::Buffer) {
         let mut vertex: Vec<BlockVertexData> = vec![];
         let mut indices: Vec<u32> = vec![];
         for x in 0..CHUNK_SIZE {
             for z in 0..CHUNK_SIZE {
-                let region = &self.blocks[(x * CHUNK_SIZE + z) as usize];
+                let region = &self.blocks[((x * CHUNK_SIZE) + z) as usize];
                 for y in 0..region.len() {
                     let block = &region[y];
-                    if let Some(block) = block {
-                        let block = block.lock().unwrap();
+                    if let Some(block_ptr) = block {
+                        let block = block_ptr.read().unwrap();
                         let position = block.position;
                         let faces = FaceDirections::all();
 
@@ -132,12 +133,15 @@ impl Chunk {
                                 );
 
                                 let target_chunk = other_chunks.iter().find(|c| {
-                                    let c = c.lock().unwrap();
+                                    let c = c.read().unwrap();
                                     c.x == target_chunk_x && c.y == target_chunk_y
                                 });
+                                // If there's a chunk loaded in memory then check that, else it means we're on a edge and we can
+                                // Calculate the block's height when the chunk gets generated
+                                // TODO: Check for saved file chunk
                                 match target_chunk {
                                     Some(chunk) => {
-                                        let chunk = chunk.lock().unwrap();
+                                        let chunk = chunk.read().unwrap();
                                         if Chunk::exists_block_at(&chunk.blocks, &target_block) {
                                             is_visible = false;
                                         }
@@ -161,7 +165,8 @@ impl Chunk {
                             }
 
                             if is_visible {
-                                let (mut vertex_data, index_data) = face.create_face_data(&block);
+                                let (mut vertex_data, index_data) =
+                                    face.create_face_data(block_ptr.clone());
                                 vertex.append(&mut vertex_data);
                                 let indices_offset = vertex.len() as u32 - 4;
                                 indices.append(
@@ -189,9 +194,11 @@ impl Chunk {
                     usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
                 });
 
-        self.indices = indices.len() as u32;
-        self.chunk_vertex_buffer = Some(chunk_vertex_buffer);
-        self.chunk_index_buffer = Some(chunk_index_buffer);
+        (
+            indices.len() as u32,
+            chunk_vertex_buffer,
+            chunk_index_buffer,
+        )
     }
     pub fn get_bind_group_layout() -> wgpu::BindGroupLayoutDescriptor<'static> {
         wgpu::BindGroupLayoutDescriptor {
@@ -246,7 +253,7 @@ impl Chunk {
                         b => b,
                     };
 
-                    let block = Arc::new(Mutex::new(Block::new(
+                    let block = Arc::new(RwLock::new(Block::new(
                         glam::vec3(x as f32, y as f32, z as f32),
                         (chunk_x, chunk_y),
                         block_type,
@@ -277,14 +284,14 @@ impl Chunk {
                 .expect("TODO: Fix this case -h")
                 .as_ref()
                 .unwrap()
-                .lock()
+                .read()
                 .unwrap()
                 .absolute_position;
 
             let tree_blocks = crate::structures::Tree::get_blocks(highest_block);
 
             for block in tree_blocks.iter() {
-                let block_brw = block.lock().unwrap();
+                let block_brw = block.read().unwrap();
                 let block_chunk = block_brw.get_chunk_coords();
                 std::mem::drop(block_brw);
                 if block_chunk == (self.x, self.y) {
@@ -303,8 +310,7 @@ impl Chunk {
         device: Arc<wgpu::Device>,
         queue: Arc<wgpu::Queue>,
         chunk_data_layout: Arc<wgpu::BindGroupLayout>,
-        other_chunks: Vec<Arc<Mutex<Chunk>>>,
-    ) -> Self {
+    ) -> Chunk {
         let mut was_loaded = false;
         let blocks = if let Ok(blocks) = Self::load(Box::new((x, y))) {
             was_loaded = true;
@@ -327,6 +333,7 @@ impl Chunk {
                 resource: chunk_position_buffer.as_entire_binding(),
             }],
         });
+
         let mut chunk = Chunk {
             blocks,
             x,
@@ -345,8 +352,6 @@ impl Chunk {
         if !was_loaded {
             chunk.place_trees();
         }
-        chunk.build_mesh(other_chunks);
-
         return chunk;
     }
 }
@@ -361,7 +366,7 @@ impl Saveable<Chunk> for Chunk {
         for col in self.blocks.iter() {
             for block in col.iter() {
                 if let Some(block_ptr) = block {
-                    let blockbrw = block_ptr.lock().unwrap();
+                    let blockbrw = block_ptr.read().unwrap();
                     data += &format!(
                         "{},{},{},{}\n",
                         blockbrw.position.x,
@@ -404,7 +409,7 @@ impl Loadable<BlockVec> for Chunk {
                 let x = coords.next().unwrap().parse::<i32>()?;
                 let y = coords.next().unwrap().parse::<i32>()?;
 
-                let mut blocks: BlockVec = vec![];
+                let mut blocks: BlockVec = vec![vec![]; (CHUNK_SIZE * CHUNK_SIZE) as usize];
                 if *chunk_position == (x, y) {
                     let file_contents = std::fs::read_to_string(format!("data/chunk{}_{}", x, y))?;
                     for line in file_contents.lines() {
@@ -421,13 +426,6 @@ impl Loadable<BlockVec> for Chunk {
                             block_type,
                         );
 
-                        if let None = blocks.get_mut(
-                            (block.position.x as u32 * CHUNK_SIZE + block.position.z as u32)
-                                as usize,
-                        ) {
-                            // This works only because chunks rows are in order
-                            blocks.push(vec![]);
-                        }
                         let y_blocks = blocks
                             .get_mut(
                                 (block.position.x as u32 * CHUNK_SIZE + block.position.z as u32)
@@ -443,7 +441,7 @@ impl Loadable<BlockVec> for Chunk {
                                 y_blocks.push(None);
                             }
                         }
-                        y_blocks[y_position] = Some(Arc::new(Mutex::new(block)));
+                        y_blocks[y_position] = Some(Arc::new(RwLock::new(block)));
                     }
                     return Ok(blocks);
                 }

src/collision.rs

@@ -136,34 +136,6 @@ impl CollisionBox {
             && point.z >= self.min_z
             && point.z <= self.max_z;
     }
-    pub fn intersects_dir(&self, other: &CollisionBox) -> Option<(f32, f32, f32)> {
-        if self.intersects(other) {
-            let mut collision_dir = (0.0, 0.0, 0.0);
-
-            // if self.max_x >= other.min_x && self.min_x < other.min_x {
-            //     collision_dir.0 = self.max_x - other.min_x;
-            // }
-            // if self.min_x <= other.max_x && self.max_x > other.max_x {
-            //     collision_dir.0 = self.min_x - other.max_x;
-            // }
-            // if self.max_y >= other.min_y && self.min_y < other.min_y {
-            //     collision_dir.1 = 1.0;
-            // }
-            // if self.min_y <= other.max_y && self.max_y > other.max_y {
-            //     collision_dir.1 = -1.0;
-            // }
-            // if self.max_z >= other.min_z && self.min_z > other.min_z {
-            //     collision_dir.2 = self.max_z - other.min_z;
-            // }
-            // if self.min_z <= other.max_z && self.max_z > other.max_z {
-            //     collision_dir.2 = self.min_z - other.max_z;
-            // }
-
-            return Some(collision_dir);
-        } else {
-            return None;
-        }
-    }
     pub fn intersects(&self, other: &CollisionBox) -> bool {
         return self.min_x <= other.max_x
             && self.max_x >= other.min_x

src/player.rs

@@ -1,7 +1,7 @@
 use std::any::Any;
 use std::error::Error;
 use std::f32::consts;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 
 use glam::{vec2, vec3, Mat2, Vec2, Vec3};
@@ -42,7 +42,7 @@ pub struct Player {
     pub is_jumping: bool,
     pub jump_action_start: Option<Instant>,
     pub is_ghost: bool,
-    pub facing_block: Option<Arc<Mutex<Block>>>,
+    pub facing_block: Option<Arc<RwLock<Block>>>,
     pub facing_face: Option<FaceDirections>,
 }
 impl Player {