cleanups

syntaxerror-9 · syntaxerror-9 · commit 190a1ffc2012 · 2024-04-21T11:20:34.000+02:00
diff --git a/src/blocks/block.rs b/src/blocks/block.rs
@@ -1,13 +1,12 @@
 use bytemuck::{Pod, Zeroable};
-use std::collections::HashMap;
 
 use super::block_type::BlockType;
 use crate::chunk::BlockVec;
 use crate::collision::CollisionBox;
 use crate::effects::ao::{convert_ao_u8_to_f32, from_vertex_position};
 use crate::world::CHUNK_SIZE;
 use glam::Vec3;
-use std::sync::{Arc, MutexGuard, RwLock};
+use std::sync::{Arc, RwLock};
 
 #[derive(Debug)]
 pub struct Block {
diff --git a/src/blocks/block_type.rs b/src/blocks/block_type.rs
@@ -1,9 +1,6 @@
-use rand::{random, rngs::StdRng, Rng, SeedableRng};
-use std::any::Any;
-
-use crate::world::{RNG_SEED, WATER_HEIGHT_LEVEL};
-
 use super::block::{FaceDirections, TexturedBlock};
+use crate::world::{RNG_SEED, WATER_HEIGHT_LEVEL};
+use rand::{rngs::StdRng, Rng, SeedableRng};
 
 #[derive(Clone, Copy, Debug)]
 // This can be 1, 2 [because sometimes we want to reuse the same texture for the bottom as the top]
diff --git a/src/effects.rs b/src/effects.rs
@@ -62,52 +62,4 @@ pub mod ao {
     pub(crate) fn convert_ao_u8_to_f32(ao: u8) -> f32 {
         1.0 - (ao as f32 / 3.0)
     }
-
-    mod test {
-        use super::*;
-        use crate::blocks::block::Block;
-        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);
-        //         }
-
-        //         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)];
-
-        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
-
-        //     assert_eq!(vao, 1);
-
-        //     let vertex_position = vec3(0.5, 0.5, -0.5); // Belongs to voxel 0,0,0
-
-        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
-
-        //     assert_eq!(vao, 2);
-
-        //     let vertex_position = vec3(-5.5, 5.5, -0.5); // Belongs to voxel 0,0,0
-
-        //     let vao = from_vertex_position(&vertex_position, &chunk_blocks);
-
-        //     assert_eq!(vao, 3);
-        // }
-    }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -8,7 +8,6 @@ use std::time::Instant;
 use winit::dpi::LogicalSize;
 use winit::window::CursorGrabMode;
 use winit::{
-    dpi::PhysicalSize,
     event::*,
     event_loop::EventLoop,
     keyboard::{Key, NamedKey},
@@ -83,9 +82,7 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                         target.exit();
                     }
 
-                    WindowEvent::KeyboardInput { event, .. } => {
-                        state.handle_keypress(event, delta_time.as_secs_f32())
-                    }
+                    WindowEvent::KeyboardInput { event, .. } => state.handle_keypress(event),
                     WindowEvent::MouseInput {
                         state: ElementState::Pressed,
                         button,
@@ -122,10 +119,10 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
 
                         if first_render {
                             // Don't do calcs based on delta time on first render
-                            state.update(0.0, 0.0);
+                            state.update(0.0);
                             first_render = false;
                         } else {
-                            state.update(delta_time.as_secs_f32(), total_time.as_secs_f32());
+                            state.update(delta_time.as_secs_f32());
                         }
                         state.draw();
                         window.lock().unwrap().request_redraw();
diff --git a/src/pipelines/highlight_selected.rs b/src/pipelines/highlight_selected.rs
@@ -1,8 +1,6 @@
-use std::sync::{Arc, RwLock};
-
 use crate::{blocks::block::FaceDirections, material::Texture, player::Player, state::State};
 
-use super::{pipeline_manager::PipelineManager, translucent::Water, Pipeline};
+use super::{pipeline_manager::PipelineManager, Pipeline};
 
 pub struct HighlightSelectedPipeline {
     pub pipeline: wgpu::RenderPipeline,
@@ -16,8 +14,8 @@ impl Pipeline for HighlightSelectedPipeline {
         state: &State,
         encoder: &mut wgpu::CommandEncoder,
         view: &wgpu::TextureView,
-        player: &std::sync::RwLockReadGuard<'_, Player>,
-        chunks: &Vec<std::sync::RwLockReadGuard<'_, crate::chunk::Chunk>>,
+        _player: &std::sync::RwLockReadGuard<'_, Player>,
+        _chunks: &Vec<std::sync::RwLockReadGuard<'_, crate::chunk::Chunk>>,
     ) -> () {
         let main_pipeline_ref = state
             .pipeline_manager
diff --git a/src/pipelines/main.rs b/src/pipelines/main.rs
@@ -1,5 +1,3 @@
-use std::sync::{Arc, RwLock};
-
 use wgpu::Face;
 
 use crate::{
@@ -21,7 +19,7 @@ pub struct MainPipeline {
 impl Pipeline for MainPipeline {
     fn render(
         &self,
-        state: &State,
+        _state: &State,
         encoder: &mut wgpu::CommandEncoder,
         view: &wgpu::TextureView,
         player: &std::sync::RwLockReadGuard<'_, Player>,
@@ -84,15 +82,12 @@ impl Pipeline for MainPipeline {
 
     fn update(
         &mut self,
-        pipeline_manager: &PipelineManager,
-        // player: Arc<RwLock<Player>>,
-        state: &State, // queue: Arc<wgpu::Queue>,
-                       // device: Arc<wgpu::Device>,
-                       // surface_configuration: &wgpu::SurfaceConfiguration,
+        _pipeline_manager: &PipelineManager,
+        _state: &State,
     ) -> Result<(), Box<dyn std::error::Error>> {
         Ok(())
     }
-    fn init(state: &State, pipeline_manager: &PipelineManager) -> Self {
+    fn init(state: &State, _pipeline_manager: &PipelineManager) -> Self {
         let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
         let swapchain_format = swapchain_capabilities.formats[0];
 
diff --git a/src/pipelines/mod.rs b/src/pipelines/mod.rs
@@ -1,7 +1,4 @@
-use std::{
-    error::Error,
-    sync::{Arc, RwLock, RwLockReadGuard},
-};
+use std::{error::Error, sync::RwLockReadGuard};
 
 use self::pipeline_manager::PipelineManager;
 use crate::{chunk::Chunk, player::Player, state::State};
diff --git a/src/pipelines/pipeline_manager.rs b/src/pipelines/pipeline_manager.rs
@@ -1,11 +1,8 @@
-use std::{
-    cell::RefCell,
-    sync::{Arc, RwLock},
-};
+use std::cell::RefCell;
 
 use wgpu::{CommandEncoder, TextureView};
 
-use crate::{player::Player, state::State};
+use crate::state::State;
 
 use super::{
     highlight_selected::HighlightSelectedPipeline, main::MainPipeline,
@@ -26,6 +23,7 @@ impl PipelineManager {
         view: &TextureView,
         main_pipeline: &MainPipeline,
     ) {
+        todo!();
     }
     pub fn init(state: &State) -> PipelineManager {
         let mut pipeline = PipelineManager {
diff --git a/src/pipelines/translucent.rs b/src/pipelines/translucent.rs
@@ -1,20 +1,12 @@
-use std::sync::{Arc, RwLock, RwLockReadGuard};
+use std::sync::RwLockReadGuard;
 
-use crate::blocks::block::{Block, FaceDirections};
+use super::pipeline_manager::PipelineManager;
+use super::Pipeline;
+use crate::blocks::block::Block;
 use crate::chunk::Chunk;
 use crate::material::Texture;
-use crate::pipeline::Uniforms;
 use crate::player::Player;
 use crate::state::State;
-use wgpu::util::DeviceExt;
-use wgpu::{
-    BindGroup, BindGroupEntry, BindGroupLayoutEntry, Buffer, BufferUsages, CommandEncoder,
-    RenderPipeline,
-};
-
-use super::main::MainPipeline;
-use super::pipeline_manager::PipelineManager;
-use super::Pipeline;
 
 pub struct Water;
 impl Water {
@@ -29,11 +21,7 @@ impl Pipeline for TranslucentPipeline {
     fn update(
         &mut self,
         _pipeline_manager: &PipelineManager,
-        state: &State,
-        // player: Arc<RwLock<Player>>,
-        // queue: Arc<wgpu::Queue>,
-        // _device: Arc<wgpu::Device>,
-        // _surface_config: &wgpu::SurfaceConfiguration,
+        _state: &State,
     ) -> Result<(), Box<dyn std::error::Error>> {
         Ok(())
     }
diff --git a/src/pipelines/ui.rs b/src/pipelines/ui.rs
@@ -1,14 +1,9 @@
-use crate::blocks;
 use crate::blocks::block::{FaceDirections, TexturedBlock};
 use crate::material::Texture;
-use crate::pipeline::Uniforms;
 use crate::player::Player;
 use crate::state::State;
-use std::borrow::Borrow;
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex, RwLock};
 use wgpu::util::DeviceExt;
-use wgpu::{BindGroup, Buffer, BufferUsages, RenderPipeline};
+use wgpu::BufferUsages;
 
 use super::pipeline_manager::PipelineManager;
 use super::Pipeline;
@@ -24,8 +19,8 @@ impl Pipeline for UIPipeline {
         state: &State,
         encoder: &mut wgpu::CommandEncoder,
         view: &wgpu::TextureView,
-        player: &std::sync::RwLockReadGuard<'_, Player>,
-        chunks: &Vec<std::sync::RwLockReadGuard<'_, crate::chunk::Chunk>>,
+        _player: &std::sync::RwLockReadGuard<'_, Player>,
+        _chunks: &Vec<std::sync::RwLockReadGuard<'_, crate::chunk::Chunk>>,
     ) -> () {
         let main_pipeline_ref = state
             .pipeline_manager
@@ -145,11 +140,8 @@ impl Pipeline for UIPipeline {
     }
     fn update(
         &mut self,
-        pipeline_manager: &PipelineManager,
-        state: &State, // player: Arc<RwLock<Player>>,
-                       // queue: Arc<wgpu::Queue>,
-                       // device: Arc<wgpu::Device>,
-                       // surface_config: &wgpu::SurfaceConfiguration,
+        _pipeline_manager: &PipelineManager,
+        state: &State,
     ) -> Result<(), Box<dyn std::error::Error>> {
         let aspect_ratio = state.surface_config.height as f32 / state.surface_config.width as f32;
         let player = state.player.read().unwrap();
@@ -162,51 +154,6 @@ impl Pipeline for UIPipeline {
             bytemuck::cast_slice(&screen_quad),
         );
         Ok(())
-
-        // let aspect_ratio = state.surface_config.height as f32 / state.surface_config.width as f32;
-
-        // let player = state.player.read().unwrap();
-        // let block_type = player.placing_block;
-        // let tex_coords = block_type.get_texcoords(FaceDirections::Front);
-        // let screen_quad = Self::create_screen_quad(aspect_ratio, tex_coords);
-        //     let player = state.player.read().unwrap();
-        //     if let Some(block_ptr) = player.facing_block.as_ref() {
-        //         let block = block_ptr.read().unwrap();
-
-        //         let face_data = FaceDirections::all()
-        //             .iter()
-        //             .find(|f| **f == player.facing_face.unwrap())
-        //             .unwrap()
-        //             .create_face_data(block_ptr.clone(), &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();
-        //         state.queue.write_buffer(
-        //             &self.vertex_buffer,
-        //             0,
-        //             bytemuck::cast_slice(&blocks_position),
-        //         );
-        //         state
-        //             .queue
-        //             .write_buffer(&self.index_buffer, 0, bytemuck::cast_slice(&face_data.1));
-        //     } else {
-        //         self.indices = 0;
-        //         state.queue.write_buffer(&self.vertex_buffer, 0, &[]);
-        //         state.queue.write_buffer(&self.index_buffer, 0, &[]);
-        //     }
-        // }
     }
 }
 impl UIPipeline {
diff --git a/src/player.rs b/src/player.rs
@@ -4,18 +4,14 @@ use std::f32::consts;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 
-use glam::{vec2, vec3, Mat2, Vec2, Vec3};
-use wgpu::util::{BufferInitDescriptor, DeviceExt};
-use wgpu::BindGroupLayout;
+use glam::{vec3, Vec2, Vec3};
+use wgpu::util::DeviceExt;
 
 use crate::blocks::block::{Block, FaceDirections};
 use crate::blocks::block_type::BlockType;
-use crate::collision::{CollisionPoint, RayResult};
+use crate::collision::RayResult;
 use crate::persistence::{Loadable, Saveable};
-use crate::{
-    collision::CollisionBox,
-    world::{World, CHUNK_SIZE},
-};
+use crate::{collision::CollisionBox, world::CHUNK_SIZE};
 
 const SENSITIVITY: f32 = 0.001;
 const CAMERA_SPEED: f32 = 10.0;
@@ -378,7 +374,7 @@ impl Saveable<glam::Vec3> for Camera {
 }
 
 impl Loadable<(glam::Vec3, f32, f32)> for Camera {
-    fn load(_: Box<dyn Any>) -> Result<((Vec3, f32, f32)), Box<dyn Error>> {
+    fn load(_: Box<dyn Any>) -> Result<(Vec3, f32, f32), Box<dyn Error>> {
         let data = String::from_utf8(std::fs::read("data/player")?)?;
         let mut data = data.split(",");
         let x = data.next().unwrap().parse::<f32>().unwrap();
diff --git a/src/state.rs b/src/state.rs
@@ -1,7 +1,6 @@
 use std::sync::Arc;
 use std::sync::{Mutex, RwLock};
 use winit::event::MouseButton;
-use winit::window::CursorGrabMode;
 use winit::{
     dpi::PhysicalSize,
     event::KeyEvent,
@@ -141,7 +140,7 @@ impl State {
         self.device.destroy();
         std::mem::drop(self.queue.to_owned());
     }
-    pub fn handle_keypress(&mut self, event: KeyEvent, delta_time: f32) {
+    pub fn handle_keypress(&mut self, event: KeyEvent) {
         let is_pressed: f32 = if event.state.is_pressed() { 1. } else { 0. };
         let mut player = self.player.write().unwrap();
 
@@ -266,7 +265,7 @@ impl State {
                 .set_depth_texture(new_depth);
         }
     }
-    pub fn update(&mut self, delta_time: f32, total_time: f32) {
+    pub fn update(&mut self, delta_time: f32) {
         let nearby_blocks = self.world.get_blocks_nearby(Arc::clone(&self.player));
 
         let mut player = self.player.write().unwrap();
diff --git a/src/utils.rs b/src/utils.rs
@@ -203,7 +203,6 @@ impl ChunkFromPosition for glam::Vec3 {
 
 mod tests {
     use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
-    use glam::vec3;
     #[test]
     fn should_get_the_correct_chunk_from_position_absolute() {
         let absolute_position = glam::vec3(17.0, 0.0, 20.0);
