feat: some refactorings

Author: syntaxerror-9

src/blocks/block.rs

@@ -1,6 +1,7 @@
 use bytemuck::{Pod, Zeroable};
 
 use super::block_type::BlockType;
+use crate::chunk::BlockVec;
 use crate::world::CHUNK_SIZE;
 use glam::Vec3;
 use std::sync::{Arc, MutexGuard, RwLock};
@@ -39,53 +40,10 @@ pub enum FaceDirections {
 }
 
 impl FaceDirections {
-    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);
-
-        let mut vertex_data: Vec<BlockVertexData> = Vec::with_capacity(4);
-
-        let mut indices_map: Vec<u32> = vec![0; 6];
-
-        for ind in indices.iter() {
-            if unique_indices.contains(ind) {
-                continue;
-            } else {
-                unique_indices.push(*ind);
-            }
-        }
-        for (i, indices_map) in indices_map.iter_mut().enumerate() {
-            let index_of = unique_indices
-                .iter()
-                .enumerate()
-                .find_map(|(k, ind)| if *ind == indices[i] { Some(k) } else { None })
-                .unwrap();
-            *indices_map = index_of as u32;
-        }
-
-        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_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],
-            })
-        });
-
-        (vertex_data, indices_map)
-    }
-
-    pub fn create_face_data_abs(
+    pub fn create_face_data(
         &self,
         block: Arc<RwLock<Block>>,
+        blocks: &BlockVec,
     ) -> (Vec<BlockVertexData>, Vec<u32>) {
         let indices = self.get_indices();
 
@@ -118,10 +76,11 @@ impl FaceDirections {
         unique_indices.iter().enumerate().for_each(|(i, index)| {
             vertex_data.push(BlockVertexData {
                 position: [
-                    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,
+                    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,
                 ],
+                ao: 0.0,
                 normal: normals.into(),
                 tex_coords: face_texcoords[i],
             })
@@ -137,6 +96,7 @@ pub struct BlockVertexData {
     pub position: [f32; 3],
     pub normal: [f32; 3],
     pub tex_coords: [f32; 2],
+    pub ao: f32,
 }
 
 impl Block {

src/chunk.rs

@@ -166,7 +166,7 @@ impl Chunk {
 
                             if is_visible {
                                 let (mut vertex_data, index_data) =
-                                    face.create_face_data(block_ptr.clone());
+                                    face.create_face_data(block_ptr.clone(), &self.blocks.clone());
                                 vertex.append(&mut vertex_data);
                                 let indices_offset = vertex.len() as u32 - 4;
                                 indices.append(
@@ -179,6 +179,7 @@ impl Chunk {
             }
         }
 
+
         let chunk_vertex_buffer =
             self.device
                 .create_buffer_init(&wgpu::util::BufferInitDescriptor {
@@ -293,7 +294,6 @@ impl Chunk {
             for block in tree_blocks.iter() {
                 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) {
                     self.add_block(block.clone());
                 } else {

src/state.rs

@@ -214,7 +214,6 @@ impl State {
                     let new_block_abs_position =
                         block_borrow.absolute_position + facing_face.get_normal_vector();
 
-                    std::mem::drop(block_borrow); /* Prevent deadlock since we'll be using when building the mesh */
                     let chunk = new_block_abs_position.get_chunk_from_position_absolute();
                     let position = new_block_abs_position.relative_from_absolute();
 

src/ui.rs

@@ -48,9 +48,20 @@ impl UI {
                 .iter()
                 .find(|f| **f == player.facing_face.unwrap())
                 .unwrap()
-                .create_face_data_abs(block_ptr.clone());
+                .create_face_data(block_ptr.clone(), &vec![]);
 
-            let blocks_position = face_data.0.iter().map(|v| v.position).collect::<Vec<_>>();
+            let blocks_position = face_data
+                .0
+                .iter()
+                .map(|v| {
+                    [
+                        // TODO: This is kinda ugly
+                        v.position[0] + (block.absolute_position.x - block.position.x),
+                        v.position[1] + (block.absolute_position.y - block.position.y),
+                        v.position[2] + (block.absolute_position.z - block.position.z),
+                    ]
+                })
+                .collect::<Vec<_>>();
 
             self.indices = face_data.1.len();
             queue.write_buffer(

src/world.rs

@@ -87,7 +87,6 @@ impl World {
             .expect("Cannot delete a block from unloaded chunk");
 
         chunks_to_rerender.push(chunk.clone());
-        std::mem::drop(block_borrow);
         let mut chunk_lock = chunk.write().unwrap();
         chunk_lock.add_block(block.clone());