feat: view frustum culling

Author: syntaxerror-9

src/chunk.rs

@@ -1,4 +1,6 @@
 use crate::persistence::{Loadable, Saveable};
+use crate::player::Player;
+use crate::utils::math_utils::Plane;
 use crate::world::WorldChunk;
 use crate::{
     blocks::{
@@ -58,6 +60,7 @@ impl Chunk {
         y_blocks[block_position.y as usize] = Some(block);
     }
     pub fn remove_block(&mut self, block_r_position: &Vec3) {
+        let mut a = 0;
         let mut blocks_borrow = self.blocks.write().unwrap();
         let y_blocks = blocks_borrow
             .get_mut(((block_r_position.x * CHUNK_SIZE as f32) + block_r_position.z) as usize)
@@ -113,7 +116,8 @@ impl Chunk {
     pub fn build_mesh(&self, other_chunks: Vec<WorldChunk>) -> (u32, wgpu::Buffer, wgpu::Buffer) {
         let mut vertex: Vec<BlockVertexData> = vec![];
         let mut indices: Vec<u32> = vec![];
-        let mut adjacent_chunks: Vec<((i32, i32), BlockVec)> = vec![((self.x, self.y), self.blocks.clone())];
+        let mut adjacent_chunks: Vec<((i32, i32), BlockVec)> =
+            vec![((self.x, self.y), self.blocks.clone())];
 
         for chunk in &other_chunks {
             let chunk_read = chunk.read().unwrap();
@@ -316,6 +320,64 @@ impl Chunk {
             }
         }
     }
+    // https://www.lighthouse3d.com/tutorials/view-frustum-culling/
+    // Note: we don't compute the top and bottom planes, only far,near,right,left
+    pub fn is_visible(&self, player: &Player) -> bool {
+        let forward = player.camera.get_forward_dir();
+        let right = player.camera.get_right_dir();
+        let halfvside = player.camera.zfar / f32::tan(player.camera.fovy / 2.0);
+        let halfhside = halfvside * player.camera.aspect_ratio;
+        let front_mult_far = player.camera.zfar * forward;
+
+        let chunk_points = [
+            (
+                (self.x as f32) * CHUNK_SIZE as f32,
+                (self.y as f32) * CHUNK_SIZE as f32,
+            ),
+            (
+                (self.x as f32 + 1.0) * CHUNK_SIZE as f32,
+                (self.y as f32) * CHUNK_SIZE as f32,
+            ),
+            (
+                (self.x as f32) * CHUNK_SIZE as f32,
+                (self.y as f32 + 1.0) * CHUNK_SIZE as f32,
+            ),
+            (
+                (self.x as f32 + 1.0) * CHUNK_SIZE as f32,
+                (self.y as f32 + 1.0) * CHUNK_SIZE as f32,
+            ),
+        ];
+
+        let near_plane = Plane {
+            point: player.camera.eye + player.camera.znear * forward,
+            normal: forward,
+        };
+        let far_plane = Plane {
+            point: player.camera.eye + front_mult_far,
+            normal: -forward,
+        };
+        let right_plane = Plane {
+            point: player.camera.eye,
+            normal: glam::vec3(0.0, 1.0, 0.0)
+                .cross(player.camera.eye - (front_mult_far + right * halfhside))
+                .normalize(),
+        };
+        let left_plane = Plane {
+            point: player.camera.eye,
+            normal: (player.camera.eye - (front_mult_far - right * halfhside))
+                .cross(glam::vec3(0.0, 1.0, 0.0))
+                .normalize(),
+        };
+
+        // returns true if at least one border of a chunk is visible is inside the frustum
+        [far_plane, near_plane, left_plane, right_plane]
+            .iter()
+            .all(|p| {
+                chunk_points.iter().any(|chunk_point| {
+                    p.signed_plane_dist(glam::vec3(chunk_point.0, 0.0, chunk_point.1)) >= 0.0
+                })
+            })
+    }
 
     pub fn new(
         x: i32,

src/main.rs

@@ -46,8 +46,6 @@ pub mod utils;
 pub mod world;
 
 async fn run(event_loop: EventLoop<()>, window: Window) {
-    // let model: Obj = load_obj(input).unwrap();
-
     let start = Instant::now();
     let mut total_time = start.elapsed();
     let mut delta_time = start.elapsed();

src/player.rs

@@ -70,7 +70,7 @@ impl Player {
         &mut self,
         collisions: &'a Vec<CollisionBox>,
     ) -> Option<(&'a CollisionBox, FaceDirections)> {
-        let forward = self.camera.calc_target();
+        let forward = self.camera.get_forward_dir();
         let mut ray_results: Vec<RayResult> = vec![];
 
         let ray = crate::collision::Ray {
@@ -142,7 +142,7 @@ impl Player {
         let input_direction = direction;
         let player_collision = self.get_collision();
 
-        let forward = self.camera.calc_target();
+        let forward = self.camera.get_forward_dir();
 
         let mut velocity = vec3(0.0, 0.0, 0.0);
 
@@ -247,13 +247,16 @@ impl Camera {
         }
     }
     pub fn build_view_matrix(&self) -> glam::Mat4 {
-        glam::Mat4::look_at_lh(self.eye, self.eye + self.calc_target(), glam::Vec3::Y)
+        glam::Mat4::look_at_lh(self.eye, self.eye + self.get_forward_dir(), glam::Vec3::Y)
     }
     pub fn build_projection_matrix(&self) -> glam::Mat4 {
         glam::Mat4::perspective_lh(self.fovy, self.aspect_ratio, self.znear, self.zfar)
     }
+    pub fn get_right_dir(&self) -> glam::Vec3 {
+        glam::vec3(0.0, 1.0, 0.0).cross(self.get_forward_dir())
+    }
 
-    pub fn calc_target(&self) -> glam::Vec3 {
+    pub fn get_forward_dir(&self) -> glam::Vec3 {
         let mut direction = glam::Vec3::ZERO;
 
         direction.x = f32::cos(self.yaw) * f32::cos(self.pitch);

src/shaders/shader.wgsl

@@ -36,6 +36,7 @@ var <uniform> current_chunk: vec2<i32>;
 fn vs_main(in: VertexInput, instance_data: InstanceInput) -> VertexOutput {
     var out: VertexOutput;
 
+
     let chunk_offset = vec4<f32>(f32(current_chunk.x) * 16.0, 0.0, f32(current_chunk.y) * 16.0, 0.0);
 
     out.clip_position = projection * view * (vec4<f32>(in.position.xyz, 1.0) + chunk_offset);
@@ -70,7 +71,7 @@ fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {
     color = textureSample(diffuse, t_sampler, in.tex_coords);
     color *= max(dot(in.normals, normalize(light_direction)), 0.2);
     color += vec4<f32>(vec3<f32>(ambient_light), 0.0);
-    color *= 1.0 - in.ao;
+    color *= 1.0 - (in.ao * 0.9);
 
     return color;
 }

src/shaders/ui_shader.wgsl

@@ -26,7 +26,6 @@ fn vs_main(in: VertexInput) -> VertexOutput {
     return out;
 }
 
-
 @group(1) @binding(0)
 var diffuse: texture_2d<f32>;
 @group(1) @binding(1)

src/state.rs

@@ -66,17 +66,7 @@ impl State {
             view_formats: vec![],
         };
 
-        let camera = Camera {
-            aspect_ratio: surface_config.width as f32 / surface_config.height as f32,
-            eye: glam::vec3(-4.0, 50.0, 4.0),
-            yaw: consts::FRAC_PI_2,
-            pitch: 0.0,
-
-            fovy: consts::FRAC_PI_4,
-            znear: 0.1,
-            zfar: 1000.,
-            needs_update: false,
-        };
+        let camera = Camera::new(surface_config.width as f32, surface_config.height as f32);
         let player = Player {
             camera,
             current_chunk: (0, 0),
@@ -345,24 +335,26 @@ impl State {
             rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
 
             for chunk in chunks.iter() {
-                rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);
-                rpass.set_vertex_buffer(
-                    0,
-                    chunk
-                        .chunk_vertex_buffer
-                        .as_ref()
-                        .expect("Vertex buffer not initiated")
-                        .slice(..),
-                );
-                rpass.set_index_buffer(
-                    chunk
-                        .chunk_index_buffer
-                        .as_ref()
-                        .expect("Index buffer not initiated")
-                        .slice(..),
-                    wgpu::IndexFormat::Uint32,
-                );
-                rpass.draw_indexed(0..chunk.indices, 0, 0..1);
+                if chunk.is_visible(&self.player) {
+                    rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);
+                    rpass.set_vertex_buffer(
+                        0,
+                        chunk
+                            .chunk_vertex_buffer
+                            .as_ref()
+                            .expect("Vertex buffer not initiated")
+                            .slice(..),
+                    );
+                    rpass.set_index_buffer(
+                        chunk
+                            .chunk_index_buffer
+                            .as_ref()
+                            .expect("Index buffer not initiated")
+                            .slice(..),
+                        wgpu::IndexFormat::Uint32,
+                    );
+                    rpass.draw_indexed(0..chunk.indices, 0, 0..1);
+                };
             }
         }
         {

src/utils.rs

@@ -8,6 +8,18 @@ fn fade(t: f32) -> f32 {
 fn lerp(a: f32, b: f32, t: f32) -> f32 {
     a + ((b - a) * t)
 }
+pub(crate) mod math_utils {
+    #[derive(Debug)]
+    pub struct Plane {
+        pub point: glam::Vec3,
+        pub normal: glam::Vec3,
+    }
+    impl Plane {
+        pub fn signed_plane_dist(&self, point: glam::Vec3) -> f32 {
+            (point - self.point).dot(self.normal)
+        }
+    }
+}
 pub(crate) mod noise {
     use std::fmt::Debug;
 
@@ -130,8 +142,10 @@ pub(crate) mod threadpool {
     impl Worker {
         pub fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
             let thread = thread::spawn(move || loop {
-                let job = receiver.lock().unwrap().recv().unwrap();
-                job();
+                let receiver = receiver.lock().unwrap();
+                if let Ok(job) = receiver.recv() {
+                    job();
+                }
             });
             Worker { id, thread }
         }