feat: placing blocks

Author: syntaxerror-9

src/blocks/block.rs

@@ -2,24 +2,18 @@ use bytemuck::{Pod, Zeroable};
 
 use super::block_type::BlockType;
 use crate::world::CHUNK_SIZE;
+use glam::Vec3;
 use std::{
     cell::RefCell,
     rc::Rc,
     sync::{Arc, Mutex, MutexGuard, Weak},
 };
 
-pub struct BlockFace {
-    pub face_direction: FaceDirections,
-    pub block: Weak<Mutex<Block>>,
-}
-
 #[derive(Debug)]
 pub struct Block {
     pub position: glam::Vec3,
     pub absolute_position: glam::Vec3,
-    pub faces: Option<Vec<FaceDirections>>,
     pub block_type: BlockType,
-    pub is_translucent: bool,
 }
 
 #[rustfmt::skip]
@@ -151,6 +145,18 @@ pub struct BlockVertexData {
 }
 
 impl Block {
+    pub fn new(position: Vec3, chunk: (i32, i32), block_type: BlockType) -> Block {
+        let absolute_position = glam::vec3(
+            (chunk.0 * CHUNK_SIZE as i32 + position.x as i32) as f32,
+            position.y,
+            (chunk.1 * CHUNK_SIZE as i32 + position.z as i32) as f32,
+        );
+        Block {
+            position,
+            block_type,
+            absolute_position,
+        }
+    }
     pub fn get_neighbour_chunks_coords(&self) -> Vec<(i32, i32)> {
         let chunk = self.get_chunk_coords();
         let mut neighbour_chunks = vec![];

src/chunk.rs

@@ -7,7 +7,7 @@ use wgpu::util::DeviceExt;
 use crate::world::World;
 use crate::{
     blocks::{
-        block::{Block, BlockFace, BlockVertexData, FaceDirections},
+        block::{Block, BlockVertexData, FaceDirections},
         block_type::BlockType,
     },
     world::{NoiseData, CHUNK_HEIGHT, CHUNK_SIZE, NOISE_CHUNK_PER_ROW, NOISE_SIZE},
@@ -31,6 +31,26 @@ pub struct Chunk {
 }
 
 impl Chunk {
+    pub fn add_block(&mut self, block: Arc<Mutex<Block>>) {
+        let block_borrow = block.lock().unwrap();
+        let y_blocks = self
+            .blocks
+            .get_mut(
+                ((block_borrow.position.x * CHUNK_SIZE as f32) + block_borrow.position.z) as usize,
+            )
+            .expect("Cannot add oob block");
+
+        println!("ADD BLOCK");
+        let start_len = y_blocks.len();
+
+        for i in start_len..block_borrow.position.y as usize {
+            println!("LOLL");
+            if i >= y_blocks.len() {
+                y_blocks.push(None);
+            }
+        }
+        y_blocks.push(Some(block.clone()));
+    }
     pub fn remove_block(&mut self, block_r_position: &Vec3) {
         let y_blocks = self
             .blocks
@@ -90,7 +110,7 @@ impl Chunk {
                     if let Some(block) = block {
                         let block = block.lock().unwrap();
                         let position = block.position;
-                        let faces = block.faces.as_ref().unwrap();
+                        let faces = FaceDirections::all();
 
                         for face in faces.iter() {
                             let mut is_visible = true;
@@ -225,22 +245,12 @@ impl Chunk {
                         b => b,
                     };
 
-                    let block = Arc::new(Mutex::new(Block {
-                        faces: None,
-                        position: glam::vec3(x as f32, y as f32, z as f32),
-                        absolute_position: glam::vec3(
-                            (chunk_x * CHUNK_SIZE as i32 + x as i32) as f32,
-                            y as f32,
-                            (chunk_y * CHUNK_SIZE as i32 + z as i32) as f32,
-                        ),
+                    let block = Arc::new(Mutex::new(Block::new(
+                        glam::vec3(x as f32, y as f32, z as f32),
+                        (chunk_x, chunk_y),
                         block_type,
-                        is_translucent: false,
-                    }));
-
-                    let face_directions =
-                        FaceDirections::all().iter().map(|f| *f).collect::<Vec<_>>();
+                    )));
 
-                    block.lock().unwrap().faces = Some(face_directions);
                     let curr = &mut blocks[((x * CHUNK_SIZE) + z) as usize];
                     curr.push(Some(block.clone()));
                 }

src/main.rs

@@ -11,7 +11,6 @@ use std::{
 use bytemuck::{Pod, Zeroable};
 use glam::vec2;
 use material::Texture;
-use model::VertexData;
 use player::CameraController;
 use state::State;
 use tobj::{load_obj, load_obj_buf, LoadOptions};
@@ -35,7 +34,6 @@ pub mod blocks;
 pub mod chunk;
 pub mod collision;
 pub mod material;
-pub mod model;
 pub mod pipeline;
 pub mod player;
 pub mod state;
@@ -59,7 +57,6 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
     let window = Arc::new(Mutex::new(window));
     let mut state = State::new(window.clone()).await;
 
-
     let mut prev_mouse_pos = glam::vec2(0.0, 0.0);
     let mut cursor_in = false;