cleanup

Author: syntaxerror-9

src/chunk.rs

@@ -1,8 +1,7 @@
-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::{ChunkMap, WorldChunk, RNG_SEED, WATER_HEIGHT_LEVEL};
+use crate::world::{ChunkMap, RNG_SEED, WATER_HEIGHT_LEVEL};
 use crate::{
     blocks::{
         block::{Block, BlockVertexData, FaceDirections},
@@ -11,15 +10,12 @@ use crate::{
     structures::Structure,
     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;
 

src/effects.rs

@@ -1,11 +1,8 @@
 pub mod ao {
     use crate::blocks::block_type::BlockType;
     use crate::chunk::BlockVec;
-    use crate::perf;
     use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
     use crate::world::CHUNK_SIZE;
-    use glam::vec3;
-    use std::time::Instant;
 
     // https://0fps.net/2013/07/03/ambient-occlusion-for-minecraft-like-worlds/
     pub(crate) fn calc_vertex_ao(side1: bool, side2: bool, up: bool) -> u8 {

src/main.rs

@@ -1,26 +1,12 @@
-use std::sync::{Arc, Mutex};
-use std::{
-    fs::File,
-    io::BufReader,
-    mem,
-    ops::ControlFlow,
-    process::exit,
-    time::{Duration, Instant},
-};
-
-use bytemuck::{Pod, Zeroable};
-use glam::vec2;
-use material::Texture;
-use player::CameraController;
 use state::State;
-use tobj::{load_obj, load_obj_buf, LoadOptions};
-use winit::keyboard::KeyCode;
+use std::sync::{Arc, Mutex};
+use std::time::Instant;
 use winit::window::CursorGrabMode;
 use winit::{
-    dpi::{PhysicalPosition, PhysicalSize},
+    dpi::PhysicalSize,
     event::*,
     event_loop::EventLoop,
-    keyboard::{Key, NamedKey, PhysicalKey},
+    keyboard::{Key, NamedKey},
     window::Window,
 };
 

src/material.rs

@@ -1,6 +1,5 @@
-use image::{error::DecodingError, GenericImageView, ImageError};
-
 use crate::{state::State, utils::noise::perlin_noise};
+use image::GenericImageView;
 
 impl Texture {
     pub const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;

src/pipeline.rs

@@ -1,17 +1,5 @@
-use std::fs::File;
-use std::io::Read;
-use std::{cell::RefCell, rc::Rc};
-
+use crate::player::Camera;
 use bytemuck::{Pod, Zeroable};
-use obj::Vertex;
-use wgpu::{include_wgsl, util::DeviceExt, BindGroup, Buffer, Face, RenderPipeline};
-
-use crate::{
-    blocks::block::Block,
-    material::{Material, Texture},
-    player::Camera,
-    state::State,
-};
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Pod, Zeroable)]

src/state.rs

@@ -1,29 +1,26 @@
+use std::sync::Arc;
 use std::sync::{Mutex, RwLock};
-use std::time::Instant;
-use std::{f32::consts, sync::Arc};
+use winit::event::MouseButton;
+use winit::window::CursorGrabMode;
+use winit::{
+    dpi::PhysicalSize,
+    event::KeyEvent,
+    keyboard::{KeyCode, PhysicalKey},
+    window::Window,
+};
 
 use crate::blocks::block::Block;
 use crate::blocks::block_type::BlockType;
-use crate::collision::CollisionBox;
-use crate::perf;
 use crate::persistence::Saveable;
 use crate::pipelines::pipeline_manager::PipelineManager;
 use crate::pipelines::Pipeline;
 use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
 use crate::{
     material::Texture,
-    pipeline::{self, Uniforms},
+    pipeline::Uniforms,
     player::{Camera, CameraController, Player},
     world::World,
 };
-use winit::event::MouseButton;
-use winit::window::CursorGrabMode;
-use winit::{
-    dpi::PhysicalSize,
-    event::KeyEvent,
-    keyboard::{KeyCode, PhysicalKey},
-    window::Window,
-};
 
 pub struct State {
     pub surface: wgpu::Surface,

src/utils.rs

@@ -1,13 +1,6 @@
 use crate::world::CHUNK_SIZE;
 use glam::{vec3, Vec3};
-use num_traits::FromPrimitive;
 
-fn fade(t: f32) -> f32 {
-    ((6.0 * t - 15.) * t + 10.) * t * t * t
-}
-fn lerp(a: f32, b: f32, t: f32) -> f32 {
-    a + ((b - a) * t)
-}
 pub(crate) mod math_utils {
     #[derive(Debug)]
     pub struct Plane {
@@ -25,7 +18,6 @@ pub(crate) mod noise {
 
     use crate::world::RNG_SEED;
 
-    use super::*;
     use glam::Vec2;
 
     const WRAP: u32 = 256;

src/world.rs

@@ -1,20 +1,15 @@
+use crate::blocks::block_type::BlockType;
+use crate::persistence::Saveable;
+use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
+use crate::{blocks::block::Block, chunk::Chunk, player::Player, utils::threadpool::ThreadPool};
 use glam::Vec3;
 use std::borrow::Borrow;
 use std::collections::HashMap;
-use std::fs::File;
-use std::ops::{Deref, DerefMut};
-use std::sync::{Mutex, RwLock};
+use std::sync::RwLock;
 use std::{
     sync::{mpsc, Arc},
     thread,
 };
-use wgpu::util::DeviceExt;
-use wgpu::BindGroupEntry;
-
-use crate::blocks::block_type::BlockType;
-use crate::persistence::Saveable;
-use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
-use crate::{blocks::block::Block, chunk::Chunk, player::Player, utils::threadpool::ThreadPool};
 
 pub const RNG_SEED: u64 = 0;
 pub const CHUNK_SIZE: u32 = 16;
@@ -23,14 +18,11 @@ pub const NOISE_SIZE: u32 = 1024;
 pub const FREQUENCY: f32 = 1. / 128.;
 pub const NOISE_CHUNK_PER_ROW: u32 = NOISE_SIZE / CHUNK_SIZE;
 pub const MAX_TREES_PER_CHUNK: u32 = 3;
-
 pub const CHUNKS_PER_ROW: u32 = 20;
 pub const CHUNKS_REGION: u32 = CHUNKS_PER_ROW * CHUNKS_PER_ROW;
 pub const WATER_HEIGHT_LEVEL: u8 = 5;
-
 // Lower bound of chunk
 pub const LB: i32 = -((CHUNKS_PER_ROW / 2) as i32);
-
 // Upper bound of chunk
 pub const UB: i32 = if CHUNKS_PER_ROW % 2 == 0 {
     (CHUNKS_PER_ROW / 2 - 1) as i32
@@ -39,7 +31,6 @@ pub const UB: i32 = if CHUNKS_PER_ROW % 2 == 0 {
 };
 
 pub type NoiseData = Vec<f32>;
-
 pub type WorldChunk = Arc<RwLock<Chunk>>;
 pub type ChunkMap = Arc<RwLock<HashMap<(i32, i32), WorldChunk>>>;
 
@@ -172,10 +163,8 @@ impl World {
                 current_chunk.0 - player_write.current_chunk.0,
                 current_chunk.1 - player_write.current_chunk.1,
             );
-
             let o = if CHUNKS_PER_ROW % 2 == 0 { 1 } else { 0 };
             let p = CHUNKS_PER_ROW as i32 / 2;
-
             let new_chunks_offset = if delta.1 > 0 || delta.0 > 0 {
                 p - o
             } else {
@@ -188,9 +177,9 @@ impl World {
             };
 
             let mut new_chunks_positions: Vec<(i32, i32)> = vec![];
-
             let chunk_y_remove = player_write.current_chunk.1 + old_chunks_offset;
             let chunk_x_remove = player_write.current_chunk.0 + old_chunks_offset;
+
             if delta.0 != 0 {
                 for i in LB + current_chunk.1..=UB + current_chunk.1 {
                     new_chunks_positions.push((current_chunk.0 + new_chunks_offset, i));
@@ -243,9 +232,9 @@ impl World {
                 })
             }
 
-            // for _ in keys_to_remove.iter() {
-            //     receiver.recv().unwrap();
-            // }
+            for _ in keys_to_remove.iter() {
+                receiver.recv().unwrap();
+            }
 
             let chunks_added = new_chunks_positions.len();
             let (sender, receiver) = mpsc::channel();