fix: small rework on material/block type loading

Author: syntaxerror-9

src/blocks/block_type.rs

@@ -9,104 +9,78 @@ pub struct FaceTexture(u32);
 #[derive(Clone, Copy, Debug)]
 pub struct BlockTypeConfigs {
     pub id: u32,
-    // The amount to add to the block id (because some blocks have more than 1 texture)
-    pub step: u32,
-    // Different texture for top face
-    pub top_texture: Option<FaceTexture>,
-    // Different texture for bottom face
-    pub bottom_texture: Option<FaceTexture>,
+    // Integers representing the nth texture to use.
+    pub textures: [FaceTexture; 3], // 1: Lateral texture, 2: Top texture, 3: Bottom texture
     pub is_translucent: bool,
 }
 
+impl BlockTypeConfigs {
+    pub fn get(block_type: BlockType) -> BlockTypeConfigs {
+        match block_type {
+            BlockType::Grass => BlockTypeConfigs {
+                id: 0,
+                textures: [FaceTexture(6), FaceTexture(7), FaceTexture(8)],
+                is_translucent: false,
+            },
+            BlockType::Dirt => BlockTypeConfigs {
+                id: 1,
+                textures: [FaceTexture(0), FaceTexture(0), FaceTexture(0)],
+                is_translucent: false,
+            },
+
+            BlockType::Water => BlockTypeConfigs {
+                id: 2,
+                textures: [FaceTexture(1), FaceTexture(1), FaceTexture(1)],
+                is_translucent: true,
+            },
+
+            BlockType::Wood => BlockTypeConfigs {
+                id: 3,
+                textures: [FaceTexture(4), FaceTexture(5), FaceTexture(5)],
+                is_translucent: false,
+            },
+            BlockType::Leaf => BlockTypeConfigs {
+                id: 4,
+                textures: [FaceTexture(2), FaceTexture(2), FaceTexture(2)],
+                is_translucent: false,
+            },
+            BlockType::Stone => BlockTypeConfigs {
+                id: 5,
+                textures: [FaceTexture(3), FaceTexture(3), FaceTexture(3)],
+                is_translucent: false,
+            },
+        }
+    }
+}
+
 #[repr(u32)]
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum BlockType {
-    Grass(BlockTypeConfigs),
-    Dirt(BlockTypeConfigs),
-    Water(BlockTypeConfigs),
-    Wood(BlockTypeConfigs),
-    Leaf(BlockTypeConfigs),
-    Stone(BlockTypeConfigs),
+    Grass,
+    Dirt,
+    Water,
+    Wood,
+    Leaf,
+    Stone,
 }
 impl BlockType {
+    pub fn get_config(&self) -> BlockTypeConfigs {
+        BlockTypeConfigs::get(*self)
+    }
+    pub fn to_id(&self) -> u32 {
+        self.get_config().id
+    }
     pub fn from_id(id: u32) -> BlockType {
         match id {
-            0 => Self::dirt(),
-            1 => Self::water(),
-            2 => Self::leaf(),
-            3 => Self::stone(),
-            4 => Self::wood(),
-            5 => Self::grass(),
+            0 => Self::Grass,
+            1 => Self::Dirt,
+            2 => Self::Water,
+            3 => Self::Wood,
+            4 => Self::Leaf,
+            5 => Self::Stone,
             _ => panic!("Invalid id"),
         }
     }
-    pub fn to_id(&self) -> u32 {
-        // meh
-        match self {
-            Self::Grass(f) => f.id,
-            Self::Dirt(f) => f.id,
-            Self::Water(f) => f.id,
-            Self::Wood(f) => f.id,
-            Self::Leaf(f) => f.id,
-            Self::Stone(f) => f.id,
-        }
-    }
-
-    pub fn dirt() -> Self {
-        Self::Dirt(BlockTypeConfigs {
-            id: 0,
-            step: 0,
-            bottom_texture: None,
-            top_texture: None,
-            is_translucent: false,
-        })
-    }
-    pub fn water() -> Self {
-        Self::Water(BlockTypeConfigs {
-            id: 1,
-            step: 0,
-            bottom_texture: None,
-            top_texture: None,
-            is_translucent: true,
-        })
-    }
-    pub fn leaf() -> Self {
-        Self::Leaf(BlockTypeConfigs {
-            id: 2,
-            step: 0,
-            bottom_texture: None,
-            top_texture: None,
-            is_translucent: false,
-        })
-    }
-    pub fn stone() -> Self {
-        Self::Stone(BlockTypeConfigs {
-            id: 3,
-            step: 0,
-            bottom_texture: None,
-            top_texture: None,
-            is_translucent: false,
-        })
-    }
-    pub fn wood() -> Self {
-        Self::Wood(BlockTypeConfigs {
-            id: 4,
-            step: 0,
-            bottom_texture: Some(FaceTexture(1)),
-            top_texture: Some(FaceTexture(1)),
-            is_translucent: false,
-        })
-    }
-
-    pub fn grass() -> Self {
-        Self::Grass(BlockTypeConfigs {
-            id: 5,
-            step: 1,
-            bottom_texture: Some(FaceTexture(2)),
-            top_texture: Some(FaceTexture(1)),
-            is_translucent: false,
-        })
-    }
 }
 impl BlockType {
     const U_STONE_THRESHOLD: u32 = 20;
@@ -118,59 +92,52 @@ impl BlockType {
             let scaler = (y as f32 - Self::U_STONE_THRESHOLD as f32) / 10.0;
             let res = t + scaler;
             if res > 1.0 {
-                BlockType::stone()
+                BlockType::Stone
             } else {
-                BlockType::dirt()
+                BlockType::Dirt
             }
         } else if y < Self::L_STONE_THRESHOLD {
-            BlockType::stone()
+            BlockType::Stone
         } else {
-            BlockType::dirt()
+            BlockType::Dirt
         }
     }
 }
 
 const TEXTURE_SIZE: u32 = 256;
 const BLOCK_PER_ROW: u32 = 8;
+// 32px per block
 const BLOCK_OFFSET: u32 = TEXTURE_SIZE / BLOCK_PER_ROW;
 const BLOCK_OFFSET_NORMALIZED: f32 = BLOCK_OFFSET as f32 / TEXTURE_SIZE as f32;
 
 fn get_base_coords(config: &BlockTypeConfigs, face_dir: FaceDirections) -> glam::Vec2 {
     let face_offset = match face_dir {
-        FaceDirections::Top => config.top_texture.unwrap_or(FaceTexture(0)),
-        FaceDirections::Bottom => config.bottom_texture.unwrap_or(FaceTexture(0)),
-        _ => FaceTexture(0),
+        FaceDirections::Top => config.textures[1],
+        FaceDirections::Bottom => config.textures[2],
+        _ => config.textures[0],
     };
+    let y_offset = (face_offset.0 / BLOCK_PER_ROW) as f32;
+    let x_offset = (face_offset.0 % BLOCK_PER_ROW) as f32;
 
-    let position = config.id + config.step + face_offset.0;
-    let wrap = position / BLOCK_PER_ROW;
-
-    let low_bound = 1.0 - (BLOCK_OFFSET_NORMALIZED + (BLOCK_OFFSET_NORMALIZED * wrap as f32));
-    let left_bound = (position as f32 % BLOCK_PER_ROW as f32) / BLOCK_PER_ROW as f32;
-    glam::vec2(left_bound, low_bound)
+    let low_bound = y_offset * BLOCK_OFFSET_NORMALIZED + BLOCK_OFFSET_NORMALIZED;
+    let left_bound = x_offset * BLOCK_OFFSET_NORMALIZED;
+    return glam::vec2(left_bound, low_bound);
 }
 fn get_tex_coords(config: &BlockTypeConfigs, face_dir: FaceDirections) -> [[f32; 2]; 4] {
     let bc = get_base_coords(config, face_dir);
     [
         [bc.x, bc.y],
-        [bc.x, bc.y + BLOCK_OFFSET_NORMALIZED],
+        [bc.x, bc.y - BLOCK_OFFSET_NORMALIZED],
         [
             bc.x + BLOCK_OFFSET_NORMALIZED,
-            bc.y + BLOCK_OFFSET_NORMALIZED,
+            bc.y - BLOCK_OFFSET_NORMALIZED,
         ],
         [bc.x + BLOCK_OFFSET_NORMALIZED, bc.y],
     ]
 }
 
 impl TexturedBlock for BlockType {
     fn get_texcoords(&self, face_dir: FaceDirections) -> [[f32; 2]; 4] {
-        match self {
-            BlockType::Grass(config) => get_tex_coords(config, face_dir),
-            BlockType::Dirt(config) => get_tex_coords(config, face_dir),
-            BlockType::Water(config) => get_tex_coords(config, face_dir),
-            BlockType::Stone(config) => get_tex_coords(config, face_dir),
-            BlockType::Wood(config) => get_tex_coords(config, face_dir),
-            BlockType::Leaf(config) => get_tex_coords(config, face_dir),
-        }
+        get_tex_coords(&self.get_config(), face_dir)
     }
 }

src/chunk.rs

@@ -1,7 +1,8 @@
+use crate::blocks::block_type::BlockType::Water;
 use crate::persistence::{Loadable, Saveable};
 use crate::player::Player;
 use crate::utils::math_utils::Plane;
-use crate::world::WorldChunk;
+use crate::world::{WorldChunk, WATER_HEIGHT_LEVEL};
 use crate::{
     blocks::{
         block::{Block, BlockVertexData, FaceDirections},
@@ -34,6 +35,8 @@ pub struct Chunk {
     pub chunk_position_buffer: wgpu::Buffer,
     pub chunk_index_buffer: Option<wgpu::Buffer>,
     pub chunk_vertex_buffer: Option<wgpu::Buffer>,
+    pub chunk_water_vertex_buffer: Option<wgpu::Buffer>,
+    pub chunk_water_index_buffer: Option<wgpu::Buffer>,
     pub outside_blocks: Vec<Arc<RwLock<Block>>>,
     pub visible: bool,
 }
@@ -68,6 +71,11 @@ impl Chunk {
             .expect("Cannot delete oob block");
         y_blocks[block_r_position.y as usize] = None;
     }
+    pub fn block_type_at(&self, position: &glam::Vec3) -> Option<BlockType> {
+        let block = self.get_block_at_relative(position)?;
+        let block_type = block.read().unwrap().block_type;
+        Some(block_type.clone())
+    }
     pub fn exists_block_at(&self, position: &glam::Vec3) -> bool {
         if let Some(y_blocks) = self
             .blocks
@@ -115,6 +123,8 @@ impl Chunk {
         }
     }
     pub fn build_mesh(&self, other_chunks: Vec<WorldChunk>) -> (u32, wgpu::Buffer, wgpu::Buffer) {
+        let mut water_vertex: Vec<BlockVertexData> = vec![];
+        let mut water_indices: Vec<u32> = vec![];
         let mut vertex: Vec<BlockVertexData> = vec![];
         let mut indices: Vec<u32> = vec![];
         let mut adjacent_chunks: Vec<((i32, i32), BlockVec)> =
@@ -182,18 +192,37 @@ impl Chunk {
                                     };
                                 }
                             }
-                        } else if self.exists_block_at(&face_position) {
+                        } else if self.exists_block_at(&face_position)
+                            && self.block_type_at(&face_position) != Some(BlockType::Water)
+                        {
                             is_visible = false;
                         }
 
                         if is_visible {
                             let (mut vertex_data, index_data) =
                                 face.create_face_data(block_ptr.clone(), &adjacent_chunks);
-                            vertex.append(&mut vertex_data);
-                            let indices_offset = vertex.len() as u32 - 4;
-                            indices.append(
-                                &mut index_data.iter().map(|i| i + indices_offset).collect(),
-                            )
+                            match block.block_type {
+                                BlockType::Water => {
+                                    water_vertex.append(&mut vertex_data);
+                                    let indices_offset = water_vertex.len() as u32 - 4;
+                                    water_indices.append(
+                                        &mut index_data
+                                            .iter()
+                                            .map(|i| i + indices_offset)
+                                            .collect(),
+                                    )
+                                }
+                                _ => {
+                                    vertex.append(&mut vertex_data);
+                                    let indices_offset = vertex.len() as u32 - 4;
+                                    indices.append(
+                                        &mut index_data
+                                            .iter()
+                                            .map(|i| i + indices_offset)
+                                            .collect(),
+                                    )
+                                }
+                            }
                         }
                     }
                 }
@@ -266,9 +295,11 @@ impl Chunk {
             for z in 0..CHUNK_SIZE {
                 let y_top = Chunk::get_height_value(chunk_x, chunk_y, x, z, noise_data.clone());
 
+                let curr = &mut blocks.write().unwrap()[((x * CHUNK_SIZE) + z) as usize];
+
                 for y in 0..=y_top {
                     let block_type = match BlockType::from_y_position(y) {
-                        BlockType::Dirt(..) if y == y_top => BlockType::grass(),
+                        BlockType::Dirt if y == y_top => BlockType::Grass,
                         b => b,
                     };
 
@@ -278,14 +309,34 @@ impl Chunk {
                         block_type,
                     )));
 
-                    let curr = &mut blocks.write().unwrap()[((x * CHUNK_SIZE) + z) as usize];
                     curr.push(Some(block.clone()));
                 }
+                // Make sure the length is at least water level
+                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);
+                        }
+                    }
+                }
             }
         }
 
         blocks
     }
+    // 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;
@@ -413,6 +464,8 @@ impl Chunk {
         });
 
         let mut chunk = Chunk {
+            chunk_water_index_buffer: None,
+            chunk_water_vertex_buffer: None,
             blocks,
             x,
             y,

src/main.rs

@@ -142,7 +142,6 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                             state.update(delta_time.as_secs_f32(), total_time.as_secs_f32());
                         }
                         state.draw();
-
                         window.lock().unwrap().request_redraw();
                     }
 

src/material.rs

@@ -124,7 +124,6 @@ impl Texture {
         let f = std::fs::File::open(path)?;
         let reader = std::io::BufReader::new(f);
         let image = image::load(reader, image::ImageFormat::Png)?;
-        let image = image.flipv();
         let dimensions = image.dimensions();
         let rgba = image.as_rgba8().unwrap();