remove unused feature

Author: syntaxerror-9

.gitignore

@@ -1,6 +1,7 @@
 /target
 .idea
 .vscode
+.vs
 data.txt
 chunks
 data

src/chunk.rs

@@ -331,9 +331,12 @@ impl Chunk {
         if z < 0 {
             z = NOISE_SIZE as i32 + (z % (NOISE_CHUNK_PER_ROW * CHUNK_SIZE) as i32);
         }
-
-        let y_top = (noise_data[((z * (NOISE_SIZE - 1) as i32) + x) as usize] + 1.0) * 0.5;
-        return (f32::powf(100.0, y_top) - 1.0) as u32;
+        if let Some(v) = noise_data.get((z * (NOISE_SIZE as i32) + x) as usize) {
+            let y_top = (v + 1.0) * 0.5;
+            return (f32::powf(100.0, y_top) - 1.0) as u32;
+        } else {
+            return 0;
+        }
     }
 
     pub fn create_blocks_data(chunk_x: i32, chunk_y: i32, noise_data: Arc<NoiseData>) -> BlockVec {

src/pipelines/highlight_selected.rs

@@ -158,7 +158,6 @@ impl Pipeline for HighlightSelectedPipeline {
                         })],
                     }),
                     primitive: wgpu::PrimitiveState {
-                        polygon_mode: state.config.polygon_mode,
                         cull_mode: Some(wgpu::Face::Front),
                         ..Default::default()
                     },

src/pipelines/main.rs

@@ -265,7 +265,6 @@ impl Pipeline for MainPipeline {
                     }),
 
                     primitive: wgpu::PrimitiveState {
-                        polygon_mode: state.config.polygon_mode,
                         cull_mode: Some(Face::Front),
                         ..Default::default()
                     },

src/pipelines/translucent.rs

@@ -96,7 +96,6 @@ impl Pipeline for TranslucentPipeline {
                         })],
                     }),
                     primitive: wgpu::PrimitiveState {
-                        polygon_mode: state.config.polygon_mode,
                         cull_mode: Some(wgpu::Face::Front),
                         ..Default::default()
                     },

src/pipelines/ui.rs

@@ -124,7 +124,6 @@ impl Pipeline for UIPipeline {
                     }),
 
                     primitive: wgpu::PrimitiveState {
-                        polygon_mode: state.config.polygon_mode,
                         cull_mode: None,
                         ..Default::default()
                     },

src/player.rs

@@ -72,6 +72,19 @@ impl Player {
             0.8,
         )
     }
+    pub fn next_placing_block(&mut self, offset: i32) {
+        // Delta is {1, -1}
+        let placing_block_id = self.placing_block.to_id();
+        let mut next_block_id = (((placing_block_id as i32 + offset as i32)
+            + (BlockType::MAX_ID + 1) as i32)
+            % (BlockType::MAX_ID + 1) as i32) as i32;
+
+        if next_block_id == BlockType::Water.to_id() as i32 {
+            next_block_id += 1 * offset as i32;
+        }
+
+        self.placing_block = BlockType::from_id(next_block_id as u32);
+    }
     // Gets the block that the player is facing
     pub fn get_facing_block<'a>(
         &mut self,

src/state.rs

@@ -33,7 +33,6 @@ pub struct State {
     pub pipeline_manager: PipelineManager,
     pub player: Arc<RwLock<Player>>,
     pub world: World,
-    pub config: Config,
     pub camera_controller: CameraController,
 }
 
@@ -57,7 +56,7 @@ impl State {
             .request_device(
                 &wgpu::DeviceDescriptor {
                     label: None,
-                    features: wgpu::Features::POLYGON_MODE_LINE,
+                    features: wgpu::Features::empty(),
                     limits: wgpu::Limits::default(),
                 },
                 None,
@@ -101,15 +100,11 @@ impl State {
         }));
 
         surface.configure(&device, &surface_config);
-        let config = Config {
-            polygon_mode: wgpu::PolygonMode::Fill,
-        };
 
         let mut world = World::init_world(device.clone(), queue.clone());
         world.init_chunks(Arc::clone(&player));
 
         let mut state = Self {
-            config,
             player,
             surface_config,
             instance,
@@ -188,13 +183,14 @@ impl State {
             } => self.camera_controller.movement_vector.y = -1.0 * is_pressed,
             KeyEvent {
                 physical_key: PhysicalKey::Code(KeyCode::KeyK),
+                state: winit::event::ElementState::Pressed,
                 ..
-            } => self
-                .window
-                .lock()
-                .unwrap()
-                .set_cursor_grab(CursorGrabMode::Confined)
-                .unwrap(),
+            } => player.next_placing_block(-1),
+            KeyEvent {
+                physical_key: PhysicalKey::Code(KeyCode::KeyJ),
+                state: winit::event::ElementState::Pressed,
+                ..
+            } => player.next_placing_block(1),
             KeyEvent {
                 physical_key: PhysicalKey::Code(KeyCode::Space),
                 state: winit::event::ElementState::Pressed,
@@ -212,17 +208,6 @@ impl State {
             } => {
                 player.is_ghost = !player.is_ghost;
             }
-            KeyEvent {
-                physical_key: PhysicalKey::Code(KeyCode::KeyF),
-                state: winit::event::ElementState::Pressed,
-                ..
-            } => {
-                if self.config.polygon_mode == wgpu::PolygonMode::Line {
-                    self.config.polygon_mode = wgpu::PolygonMode::Fill
-                } else {
-                    self.config.polygon_mode = wgpu::PolygonMode::Line
-                }
-            }
             _ => {}
         }
     }
@@ -258,17 +243,10 @@ impl State {
         }
     }
     pub fn handle_wheel(&mut self, delta: f32) {
-        // Delta is {1.0, -1.0}
-        let palcing_block_id = self.player.read().unwrap().placing_block.to_id();
-        let mut next_block_id = (((palcing_block_id as i32 + delta as i32)
-            + (BlockType::MAX_ID + 1) as i32)
-            % (BlockType::MAX_ID + 1) as i32) as i32;
-
-        if next_block_id == BlockType::Water.to_id() as i32 {
-            next_block_id += 1 * delta as i32;
-        }
-
-        self.player.write().unwrap().placing_block = BlockType::from_id(next_block_id as u32);
+        self.player
+            .write()
+            .unwrap()
+            .next_placing_block(delta as i32);
     }
     pub fn handle_mouse(&mut self, delta: &glam::Vec2) {
         self.player.write().unwrap().camera.move_target(delta)