fix: better saving system and include in binary the shaders

syntaxerror-9 · syntaxerror-9 · commit 7d13f0a0438c · 2024-04-06T17:37:21.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,7 +3,6 @@ name = "minecraft"
 version = "0.1.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 winit = { version = "0.29", features = ["rwh_05", "rwh_06"] }
@@ -25,10 +24,13 @@ default-features = false
 features = ["png", "jpeg"]
 
 
+
 [build-dependencies]
 anyhow = "1.0"
 fs_extra = "1.2"
 glob = "0.3"
 
 [build]
 rustflags = ["-Z", "threads=8"]
+[profile.release]
+debug = 1
diff --git a/src/chunk.rs b/src/chunk.rs
@@ -12,10 +12,13 @@ use crate::{
     world::{NoiseData, CHUNK_SIZE, MAX_TREES_PER_CHUNK, NOISE_CHUNK_PER_ROW, NOISE_SIZE},
 };
 use glam::Vec3;
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
 use std::any::Any;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::error::Error;
+use std::io::{self, BufReader, Read};
 use std::rc::Rc;
 use std::sync::{Arc, RwLock};
 use wgpu::util::DeviceExt;
@@ -40,10 +43,11 @@ pub struct Chunk {
     pub chunk_water_index_buffer: Option<wgpu::Buffer>,
     pub outside_blocks: Vec<Arc<RwLock<Block>>>,
     pub visible: bool,
+    pub modified: bool, // if it should be saved
 }
 
 impl Chunk {
-    pub fn add_block(&mut self, block: Arc<RwLock<Block>>) {
+    pub fn add_block(&mut self, block: Arc<RwLock<Block>>, modify_status: bool) {
         let block_borrow = block.read().unwrap();
         let block_position = block_borrow.position;
         std::mem::drop(block_borrow);
@@ -63,14 +67,17 @@ impl Chunk {
         }
 
         y_blocks[block_position.y as usize] = Some(block);
+        if modify_status {
+            self.modified = true;
+        }
     }
     pub fn remove_block(&mut self, block_r_position: &Vec3) {
-        let mut a = 0;
         let mut blocks_borrow = self.blocks.write().unwrap();
         let y_blocks = blocks_borrow
             .get_mut(((block_r_position.x * CHUNK_SIZE as f32) + block_r_position.z) as usize)
             .expect("Cannot delete oob block");
         y_blocks[block_r_position.y as usize] = None;
+        self.modified = true;
     }
     pub fn block_type_at(&self, position: &glam::Vec3) -> Option<BlockType> {
         let block = self.get_block_at_relative(position)?;
@@ -163,6 +170,10 @@ impl Chunk {
                     let faces = FaceDirections::all();
 
                     for face in faces.iter() {
+                        // For water block types, we only care about the top face
+                        if block.block_type == BlockType::Water && *face != FaceDirections::Top {
+                            continue;
+                        }
                         let mut is_visible = true;
                         let face_position = face.get_normal_vector() + position;
 
@@ -218,7 +229,6 @@ impl Chunk {
                             }
                         } else if self.exists_block_at(&face_position) {
                             is_visible = false;
-
                             // This can be a oneline if, but it gets very hard to read
                             if self.block_type_at(&face_position) == Some(BlockType::Water)
                                 && block.block_type != BlockType::Water
@@ -336,7 +346,12 @@ impl Chunk {
 
     pub fn create_blocks_data(chunk_x: i32, chunk_y: i32, noise_data: Arc<NoiseData>) -> BlockVec {
         let size = (CHUNK_SIZE * CHUNK_SIZE) as usize;
-        let mut blocks: BlockVec = Arc::new(RwLock::new(vec![vec![]; size]));
+        let blocks: BlockVec = Arc::new(RwLock::new(vec![
+            Vec::with_capacity(
+                WATER_HEIGHT_LEVEL as usize
+            );
+            size
+        ]));
 
         for x in 0..CHUNK_SIZE {
             for z in 0..CHUNK_SIZE {
@@ -358,24 +373,15 @@ impl Chunk {
 
                     curr.push(Some(block.clone()));
                 }
-                // Make sure the length is at least water level
+                // Fill with water empty blocks
                 for y in curr.len()..=(WATER_HEIGHT_LEVEL as usize) {
                     if let None = curr.get(y) {
-                        curr.push(None);
-                    }
-                }
-
-                for y in 0..=WATER_HEIGHT_LEVEL as usize {
-                    if let Some(entry) = curr.get(y) {
-                        // If there's not a block on this level, place water
-                        if let None = entry {
-                            let block = Arc::new(RwLock::new(Block::new(
-                                glam::vec3(x as f32, y as f32, z as f32),
-                                (chunk_x, chunk_y),
-                                BlockType::Water,
-                            )));
-                            curr[y as usize] = Some(block);
-                        }
+                        let block = Arc::new(RwLock::new(Block::new(
+                            glam::vec3(x as f32, y as f32, z as f32),
+                            (chunk_x, chunk_y),
+                            BlockType::Water,
+                        )));
+                        curr.push(Some(block));
                     }
                 }
             }
@@ -385,34 +391,48 @@ impl Chunk {
     }
     // TODO: Use white noise + check that the tree is not being placed on water.
     pub fn place_trees(&mut self) {
-        let number_of_trees = rand::random::<f32>();
-        let number_of_trees = f32::floor(number_of_trees * MAX_TREES_PER_CHUNK as f32) as u32;
-
-        for _ in 0..number_of_trees {
-            let x = f32::floor(rand::random::<f32>() * CHUNK_SIZE as f32) as usize;
-            let z = f32::floor(rand::random::<f32>() * CHUNK_SIZE as f32) as usize;
-
-            let blocks_read = self.blocks.read().unwrap();
-            let block_column = blocks_read
-                .get((x * CHUNK_SIZE as usize) + z)
-                .expect("TODO: fix this case");
-            let highest_block = block_column
-                .last()
-                .expect("TODO: Fix this case -h")
-                .as_ref()
-                .unwrap()
-                .read()
-                .unwrap()
-                .absolute_position;
-            std::mem::drop(blocks_read);
-
-            let tree_blocks = crate::structures::Tree::get_blocks(highest_block);
+        let mut rng = StdRng::seed_from_u64((self.x * 10 * self.y) as u64);
+        let number_of_trees = rng.gen::<f32>();
+        let mut number_of_trees = f32::floor(number_of_trees * MAX_TREES_PER_CHUNK as f32) as u32;
+
+        // Do a max 100 retries
+        for _ in 0..100 {
+            if number_of_trees == 0 {
+                break;
+            }
+            let mut tree_blocks = vec![];
+            {
+                let x = f32::floor(rng.gen::<f32>() * CHUNK_SIZE as f32) as usize;
+                let z = f32::floor(rng.gen::<f32>() * CHUNK_SIZE as f32) as usize;
+
+                let blocks_read = self.blocks.read().unwrap();
+                let block_column = blocks_read
+                    .get((x * CHUNK_SIZE as usize) + z)
+                    .expect("TODO: fix this case");
+                let highest_block = block_column
+                    .last()
+                    .expect("TODO: Fix this case -h")
+                    .as_ref()
+                    .unwrap()
+                    .read()
+                    .unwrap();
+                if highest_block.block_type == BlockType::Water
+                    || highest_block.block_type == BlockType::Leaf
+                {
+                    continue;
+                }
+                let highest_block_position = highest_block.absolute_position.clone();
 
+                tree_blocks.append(&mut crate::structures::Tree::get_blocks(
+                    highest_block_position,
+                ));
+                number_of_trees -= 1;
+            }
             for block in tree_blocks.iter() {
                 let block_brw = block.read().unwrap();
                 let block_chunk = block_brw.get_chunk_coords();
                 if block_chunk == (self.x, self.y) {
-                    self.add_block(block.clone());
+                    self.add_block(block.clone(), false);
                 } else {
                     self.outside_blocks.push(block.clone())
                 }
@@ -488,6 +508,7 @@ impl Chunk {
         chunk_data_layout: Arc<wgpu::BindGroupLayout>,
     ) -> Chunk {
         let mut was_loaded = false;
+
         let blocks = if let Ok(blocks) = Self::load(Box::new((x, y))) {
             was_loaded = true;
             blocks
@@ -511,6 +532,7 @@ impl Chunk {
         });
 
         let mut chunk = Chunk {
+            modified: false,
             chunk_water_index_buffer: None,
             chunk_water_vertex_buffer: None,
             blocks,
@@ -582,7 +604,7 @@ impl Loadable<BlockVec> for Chunk {
                 let y = coords.next().unwrap().parse::<i32>()?;
 
                 let size = (CHUNK_SIZE * CHUNK_SIZE) as usize;
-                let mut blocks: BlockVec = Arc::new(RwLock::new(vec![vec![]; size]));
+                let blocks: BlockVec = Arc::new(RwLock::new(vec![vec![]; size]));
                 if *chunk_position == (x, y) {
                     let file_contents = std::fs::read_to_string(format!("data/chunk{}_{}", x, y))?;
                     for line in file_contents.lines() {
diff --git a/src/effects.rs b/src/effects.rs
@@ -1,4 +1,5 @@
 pub mod ao {
+    use crate::blocks::block_type::BlockType;
     use crate::chunk::BlockVec;
     use crate::perf;
     use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
@@ -49,8 +50,10 @@ pub mod ao {
                 let blocks = blocks.read().unwrap();
                 let ycol = &blocks[((position.x * CHUNK_SIZE as f32) + position.z) as usize];
                 if let Some(place) = ycol.get(position.y as usize) {
-                    if let Some(_) = place {
-                        *val = true
+                    if let Some(block) = place {
+                        if block.read().unwrap().block_type != BlockType::Water {
+                            *val = true
+                        }
                     }
                 }
             }
@@ -69,45 +72,45 @@ pub mod ao {
         use crate::blocks::block_type::BlockType;
         use std::sync::{Arc, RwLock};
 
-        #[test]
-        fn should_calculate_the_correct_ao() {
-            let vertex_position = vec3(0.5, 0.5, 0.5); // Belongs to voxel 0,0,0
-            let block_vec: BlockVec = Arc::new(RwLock::new(vec![
-                vec![];
-                (CHUNK_SIZE * CHUNK_SIZE) as usize
-            ]));
-            let neighbour_voxels = [vec3(1.0, 1.0, 0.0), vec3(1.0, 1.0, 1.0)];
-            for voxel in &neighbour_voxels {
-                let mut block_write = block_vec.write().unwrap();
-                let region = &mut block_write[((voxel.x * CHUNK_SIZE as f32) + voxel.z) as usize];
-
-                for _ in region.len()..=voxel.y as usize {
-                    region.push(None);
-                }
+        // #[test]
+        // fn should_calculate_the_correct_ao() {
+        //     let vertex_position = vec3(0.5, 0.5, 0.5); // Belongs to voxel 0,0,0
+        //     let block_vec: BlockVec = Arc::new(RwLock::new(vec![
+        //         vec![];
+        //         (CHUNK_SIZE * CHUNK_SIZE) as usize
+        //     ]));
+        //     let neighbour_voxels = [vec3(1.0, 1.0, 0.0), vec3(1.0, 1.0, 1.0)];
+        //     for voxel in &neighbour_voxels {
+        //         let mut block_write = block_vec.write().unwrap();
+        //         let region = &mut block_write[((voxel.x * CHUNK_SIZE as f32) + voxel.z) as usize];
 
-                region[voxel.y as usize] = Some(Arc::new(RwLock::new(Block::new(
-                    voxel.clone(),
-                    voxel.get_chunk_from_position_absolute(),
-                    BlockType::dirt(),
-                ))));
-            }
-            let chunk_blocks = vec![((0, 0), block_vec)];
+        //         for _ in region.len()..=voxel.y as usize {
+        //             region.push(None);
+        //         }
 
-            let vao = from_vertex_position(&vertex_position, &chunk_blocks);
+        //         region[voxel.y as usize] = Some(Arc::new(RwLock::new(Block::new(
+        //             voxel.clone(),
+        //             voxel.get_chunk_from_position_absolute(),
+        //             BlockType::dirt(),
+        //         ))));
+        //     }
+        //     let chunk_blocks = vec![((0, 0), block_vec)];
 
-            assert_eq!(vao, 1);
+        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
 
-            let vertex_position = vec3(0.5, 0.5, -0.5); // Belongs to voxel 0,0,0
+        //     assert_eq!(vao, 1);
 
-            let vao = from_vertex_position(&vertex_position, &chunk_blocks);
+        //     let vertex_position = vec3(0.5, 0.5, -0.5); // Belongs to voxel 0,0,0
 
-            assert_eq!(vao, 2);
+        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
 
-            let vertex_position = vec3(-5.5, 5.5, -0.5); // Belongs to voxel 0,0,0
+        //     assert_eq!(vao, 2);
 
-            let vao = from_vertex_position(&vertex_position, &chunk_blocks);
+        //     let vertex_position = vec3(-5.5, 5.5, -0.5); // Belongs to voxel 0,0,0
 
-            assert_eq!(vao, 3);
-        }
+        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
+
+        //     assert_eq!(vao, 3);
+        // }
     }
 }
diff --git a/src/pipeline.rs b/src/pipeline.rs
@@ -39,7 +39,7 @@ impl Pipeline {
         let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
         let swapchain_format = swapchain_capabilities.formats[0];
 
-        let shader_source = std::fs::read_to_string("src/shaders/shader.wgsl").unwrap();
+        let shader_source = include_str!("./shaders/shader.wgsl");
 
         let shader = state
             .device
diff --git a/src/shaders/water_shader.wgsl b/src/shaders/water_shader.wgsl
@@ -74,7 +74,7 @@ struct FragmentInput {
 fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {
     var color: vec4<f32>;
     color = textureSample(diffuse, t_sampler, in.tex_coords);
-    color.a = 0.1;
+    color.a = 0.6;
 
     return color;
 }
diff --git a/src/ui.rs b/src/ui.rs
@@ -112,7 +112,7 @@ impl UIPipeline {
         let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
         let swapchain_format = swapchain_capabilities.formats[0];
 
-        let shader_source = std::fs::read_to_string("src/shaders/ui_shader.wgsl").unwrap();
+        let shader_source = include_str!("./shaders/ui_shader.wgsl");
 
         let shader = state
             .device
diff --git a/src/water.rs b/src/water.rs
@@ -28,7 +28,7 @@ impl WaterPipeline {
         let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
         let swapchain_format = swapchain_capabilities.formats[0];
 
-        let shader_source = std::fs::read_to_string("src/shaders/water_shader.wgsl").unwrap();
+        let shader_source = include_str!("./shaders/water_shader.wgsl");
 
         let shader = state
             .device
diff --git a/src/world.rs b/src/world.rs

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ struct FragmentInput {`
`74`	`74`	`fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {`
`75`	`75`	`var color: vec4<f32>;`
`76`	`76`	`color = textureSample(diffuse, t_sampler, in.tex_coords);`
`77`		`- color.a = 0.1;`
	`77`	`+ color.a = 0.6;`
`78`	`78`
`79`	`79`	`return color;`
`80`	`80`	`}`