feat: facing blocks

Author: syntaxerror-9

src/main.rs

@@ -1,3 +1,4 @@
+use std::sync::{Arc, Mutex};
 use std::{
     fs::File,
     io::BufReader,
@@ -8,12 +9,14 @@ use std::{
 };
 
 use bytemuck::{Pod, Zeroable};
-use player::CameraController;
 use glam::vec2;
 use material::Texture;
 use model::VertexData;
+use player::CameraController;
 use state::State;
 use tobj::{load_obj, load_obj_buf, LoadOptions};
+use winit::keyboard::KeyCode;
+use winit::window::CursorGrabMode;
 use winit::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::*,
@@ -29,16 +32,16 @@ const DEFAULT_WINDOW_HEIGHT: u32 = 800;
 extern crate lazy_static;
 
 pub mod blocks;
-pub mod player;
 pub mod chunk;
 pub mod collision;
 pub mod material;
 pub mod model;
 pub mod pipeline;
+pub mod player;
 pub mod state;
+pub mod ui;
 pub mod utils;
 pub mod world;
-pub mod ui;
 
 async fn run(event_loop: EventLoop<()>, window: Window) {
     // let model: Obj = load_obj(input).unwrap();
@@ -51,11 +54,12 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
     size.width = size.width.max(1);
     size.width = size.height.max(1);
 
-    let mut state = State::new(&window).await;
-    let 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;
+    let mut cursor_grab = CursorGrabMode::None;
 
     event_loop
         .run(move |event, target| {
@@ -69,7 +73,7 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                 match event {
                     WindowEvent::Resized(new_size) => {
                         state.resize(new_size);
-                        window.request_redraw();
+                        window.lock().unwrap().request_redraw();
                     }
                     // WindowEvent::RedrawRequested => {}
                     WindowEvent::CloseRequested
@@ -110,7 +114,7 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                         state.update(delta_time.as_secs_f32(), total_time.as_secs_f32());
                         state.draw();
 
-                        window.request_redraw();
+                        window.lock().unwrap().request_redraw();
                     }
 
                     _ => {}

src/player.rs

@@ -3,7 +3,7 @@ use std::time::{Duration, Instant};
 
 use glam::{vec2, vec3, Mat2, Vec2, Vec3};
 
-use crate::blocks::block::Block;
+use crate::blocks::block::{Block, FaceDirections};
 use crate::collision::{CollisionPoint, RayResult};
 use crate::{
     collision::CollisionBox,
@@ -39,6 +39,7 @@ pub struct Player {
     pub jump_action_start: Option<Instant>,
     pub is_ghost: bool,
     pub facing_block: Option<Arc<Mutex<Block>>>,
+    pub facing_face: Option<FaceDirections>,
 }
 impl Player {
     // Position relative to the chunk
@@ -64,7 +65,7 @@ impl Player {
     pub fn get_facing_block<'a>(
         &mut self,
         collisions: &'a Vec<CollisionBox>,
-    ) -> Option<&'a CollisionBox> {
+    ) -> Option<(&'a CollisionBox, FaceDirections)> {
         let forward = self.camera.calc_target();
         let mut ray_results: Vec<RayResult> = vec![];
 
@@ -84,6 +85,7 @@ impl Player {
 
         let mut block_collision: Option<&CollisionBox> = None;
         let mut max_distance = f32::MAX;
+        let mut point: Option<Vec3> = None;
 
         for result in ray_results.iter() {
             let mut closest_point = result.points[0];
@@ -95,10 +97,30 @@ impl Player {
             if closest_point.distance(self.camera.eye) < max_distance {
                 max_distance = closest_point.distance(self.camera.eye);
                 block_collision = Some(result.collision);
+                point = Some(closest_point.clone());
             }
         }
-
-        return block_collision;
+        let mut face_direction = None;
+
+        return match (block_collision, point) {
+            (Some(block_collision), Some(point)) => {
+                // TODO: This can be precomputed
+
+                let point_dir = ((block_collision.center() - point).normalize()) * -1.0;
+
+                let face_directions = FaceDirections::all();
+                let mut best_dot = -1.0;
+                for face in face_directions.iter() {
+                    let dot = point_dir.dot(face.get_normal_vector());
+                    if dot > best_dot {
+                        best_dot = dot;
+                        face_direction = Some(face);
+                    }
+                }
+                Some((block_collision, *face_direction.unwrap()))
+            }
+            _ => None,
+        };
     }
     pub fn calc_current_chunk(&self) -> (i32, i32) {
         (

src/state.rs

@@ -1,3 +1,5 @@
+use std::ops::Deref;
+use std::sync::Mutex;
 use std::{cell::RefCell, f32::consts, rc::Rc, sync::Arc};
 
 use crate::collision::CollisionBox;
@@ -12,6 +14,7 @@ use crate::{
 };
 use glam::{vec2, Quat, Vec3};
 use wgpu::{util::DeviceExt, BufferUsages};
+use winit::window::CursorGrabMode;
 use winit::{
     dpi::{LogicalSize, PhysicalSize},
     event::{DeviceEvent, ElementState, KeyEvent},
@@ -20,10 +23,11 @@ use winit::{
 };
 
 impl State {
-    pub async fn new(window: &Window) -> Self {
-        let size = window.inner_size();
+    pub async fn new(window: Arc<Mutex<Window>>) -> Self {
+        let windowbrw = window.lock().unwrap();
+        let size = windowbrw.inner_size();
         let instance = wgpu::Instance::default();
-        let surface = unsafe { instance.create_surface(&window).unwrap() };
+        let surface = unsafe { instance.create_surface(&*windowbrw).unwrap() };
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
                 power_preference: wgpu::PowerPreference::default(),
@@ -78,6 +82,7 @@ impl State {
             is_jumping: false,
             on_ground: false,
             facing_block: None,
+            facing_face: None,
             jump_action_start: None,
             is_ghost: false,
         };
@@ -97,6 +102,7 @@ impl State {
             pipelines: vec![],
             surface_config,
             instance,
+            window: window.clone(),
             device,
             world,
             queue,
@@ -141,6 +147,15 @@ impl State {
                 physical_key: PhysicalKey::Code(KeyCode::KeyQ),
                 ..
             } => self.camera_controller.movement_vector.y = -1.0 * is_pressed,
+            KeyEvent {
+                physical_key: PhysicalKey::Code(KeyCode::KeyK),
+                ..
+            } => self
+                .window
+                .lock()
+                .unwrap()
+                .set_cursor_grab(CursorGrabMode::Confined)
+                .unwrap(),
             KeyEvent {
                 physical_key: PhysicalKey::Code(KeyCode::Space),
                 state: winit::event::ElementState::Pressed,
@@ -168,9 +183,6 @@ impl State {
                 } else {
                     self.config.polygon_mode = wgpu::PolygonMode::Line
                 }
-
-                // self.pipelines.pop();
-                // self.pipelines.push(Box::new(Pipeline::new(&self)))
             }
             _ => {}
         }
@@ -206,9 +218,10 @@ impl State {
             delta_time,
             &collisions,
         );
-        if let Some(block) = self.player.get_facing_block(&collisions) {
+        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);
         }
 
         let uniforms = Uniforms::from(&self.player.camera);
@@ -340,6 +353,7 @@ pub struct State {
     pub adapter: wgpu::Adapter,
     pub device: Arc<wgpu::Device>,
     pub queue: Arc<wgpu::Queue>,
+    pub window: Arc<Mutex<Window>>,
     pub surface_config: wgpu::SurfaceConfiguration,
     pub pipelines: Vec<Box<dyn PipelineTrait>>,
     pub player: Player,

src/ui.rs

@@ -47,7 +47,7 @@ impl UI {
                 .as_ref()
                 .unwrap()
                 .iter()
-                .find(|f| f.face_direction == FaceDirections::Top)
+                .find(|f| f.face_direction == player.facing_face.unwrap())
                 .unwrap()
                 .create_face_data_abs(&block);