fix: miscalculated array sizing

Author: syntaxerror-9

src/chunk.rs

@@ -40,16 +40,15 @@ impl Chunk {
             )
             .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");
+        /* Make sure we don't have enough space in the vector */
+        for i in start_len..=block_borrow.position.y as usize {
             if i >= y_blocks.len() {
                 y_blocks.push(None);
             }
         }
-        y_blocks.push(Some(block.clone()));
+        y_blocks[block_borrow.position.y as usize] = Some(block.clone());
     }
     pub fn remove_block(&mut self, block_r_position: &Vec3) {
         let y_blocks = self
@@ -144,12 +143,12 @@ impl Chunk {
                                     None => {
                                         if face_position.y as u32
                                             <= Chunk::get_height_value(
-                                            target_chunk_x,
-                                            target_chunk_y,
-                                            target_block.x as u32,
-                                            target_block.z as u32,
-                                            self.noise_data.clone(),
-                                        )
+                                                target_chunk_x,
+                                                target_chunk_y,
+                                                target_block.x as u32,
+                                                target_block.z as u32,
+                                                self.noise_data.clone(),
+                                            )
                                         {
                                             is_visible = false
                                         };

src/collision.rs

@@ -69,7 +69,7 @@ impl Ray {
             tzmax = (collision_box.min_z - self.origin.z) * invdirz;
         }
 
-        if tmin > tzmax || tzmin > tmax {
+        if tmin > tzmax || tzmin > tmax || tmin < 0.0 || tmax < 0.0 {
             return None;
         }
 
@@ -87,6 +87,7 @@ impl Ray {
     }
 }
 
+#[derive(Debug)]
 pub struct RayResult<'a> {
     pub points: Vec<glam::Vec3>,
     pub collision: &'a CollisionBox,
@@ -117,7 +118,7 @@ impl CollisionBox {
         }
     }
     pub fn to_block_position(&self) -> glam::Vec3 {
-        glam::vec3(self.min_x, self.min_y, self.min_z)
+        return glam::vec3(self.min_x, self.min_y, self.min_z);
     }
     pub fn new(x: f32, y: f32, z: f32, width: f32, height: f32, depth: f32) -> CollisionBox {
         CollisionBox {

src/state.rs

@@ -249,6 +249,7 @@ impl State {
         );
         if let Some((block, face_dir)) = self.player.get_facing_block(&collisions) {
             let block = self.world.get_blocks_absolute(&block.to_block_position());
+
             self.player.facing_block = block;
             self.player.facing_face = Some(face_dir);
         } else {
@@ -386,7 +387,7 @@ impl State {
             ui_renderpass.set_vertex_buffer(0, self.ui.vertex_buffer.slice(..));
             ui_renderpass
                 .set_index_buffer(self.ui.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
-            ui_renderpass.draw_indexed(0..6, 0, 0..1);
+            ui_renderpass.draw_indexed(0..self.ui.indices as u32, 0, 0..1);
         }
 
         self.queue.submit(Some(encoder.finish()));

src/ui.rs

@@ -10,6 +10,7 @@ use wgpu::{BindGroup, Buffer, RenderPipeline};
 pub struct UI {
     pub vertex_buffer: wgpu::Buffer,
     pub index_buffer: wgpu::Buffer,
+    pub indices: usize,
 }
 
 impl UI {
@@ -34,6 +35,7 @@ impl UI {
         });
 
         Self {
+            indices: 0,
             vertex_buffer,
             index_buffer,
         }
@@ -50,12 +52,17 @@ impl UI {
 
             let blocks_position = face_data.0.iter().map(|v| v.position).collect::<Vec<_>>();
 
+            self.indices = face_data.1.len();
             queue.write_buffer(
                 &self.vertex_buffer,
                 0,
                 bytemuck::cast_slice(&blocks_position),
             );
             queue.write_buffer(&self.index_buffer, 0, bytemuck::cast_slice(&face_data.1));
+        } else {
+            self.indices = 0;
+            queue.write_buffer(&self.vertex_buffer, 0, &[]);
+            queue.write_buffer(&self.index_buffer, 0, &[]);
         }
     }
 

src/world.rs

@@ -1,3 +1,4 @@
+use glam::Vec3;
 use std::any::Any;
 use std::ffi::c_void;
 use std::ops::Deref;
@@ -148,7 +149,7 @@ impl World {
             }
         }
     }
-    pub fn get_blocks_absolute(&self, position: &glam::Vec3) -> Option<Arc<Mutex<Block>>> {
+    pub fn get_blocks_absolute(&self, position: &Vec3) -> Option<Arc<Mutex<Block>>> {
         let (chunk_x, chunk_y) = position.get_chunk_from_position_absolute();
 
         let chunk = self.chunks.iter().find(|c| {
@@ -159,6 +160,7 @@ impl World {
 
         let relative_position = position.relative_from_absolute();
         let block = chunk.get_block_at_relative(&relative_position)?;
+
         return Some(block);
     }
     pub fn get_blocks_nearby(&self, player: &Player) -> Option<Vec<Arc<Mutex<Block>>>> {