feat: fog

Author: syntaxerror-9

src/pipeline.rs

@@ -173,6 +173,7 @@ impl Pipeline {
                         &bind_group_0_layout,
                         &bind_group_1_layout,
                         &state.world.chunk_data_layout,
+                        &state.player.read().unwrap().camera.position_bind_group_layout
                     ],
                     push_constant_ranges: &[],
                 });
@@ -244,7 +245,6 @@ impl PipelineTrait for Pipeline {
     fn bind_group_0(&self) -> &BindGroup {
         &self.bind_group_0
     }
-
     fn bind_group_1(&self) -> &BindGroup {
         &self.bind_group_1
     }

src/player.rs

@@ -5,6 +5,8 @@ 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 crate::blocks::block::{Block, FaceDirections};
 use crate::collision::{CollisionPoint, RayResult};
@@ -46,6 +48,13 @@ pub struct Player {
     pub facing_face: Option<FaceDirections>,
 }
 impl Player {
+    pub fn update(&mut self) {
+        self.camera.queue.write_buffer(
+            &self.camera.position_buffer,
+            0,
+            bytemuck::cast_slice(&[self.camera.eye]),
+        )
+    }
     // Position relative to the chunk
     pub fn to_relative_position(&self) -> glam::Vec3 {
         todo!();
@@ -220,21 +229,64 @@ pub struct Camera {
     pub znear: f32,
     pub zfar: f32,
     pub needs_update: bool,
+    pub device: Arc<wgpu::Device>,
+    pub queue: Arc<wgpu::Queue>,
+    pub position_buffer: wgpu::Buffer,
+    pub position_bind_group: wgpu::BindGroup,
+    pub position_bind_group_layout: wgpu::BindGroupLayout,
 }
 
 impl Camera {
-    pub fn new(surface_width: f32, surface_height: f32) -> Camera {
+    pub fn new(
+        surface_width: f32,
+        surface_height: f32,
+        device: Arc<wgpu::Device>,
+        queue: Arc<wgpu::Queue>,
+    ) -> Camera {
         let (eye, yaw, pitch) = if let Ok((eye, yaw, pitch)) = Camera::load(Box::new(())) {
             (eye, yaw, pitch)
         } else {
             (glam::vec3(-4.0, 50.0, 4.0), consts::FRAC_PI_2, 0.0)
         };
+
+        let position_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            contents: bytemuck::cast_slice(&[eye]),
+            label: Some("camera-position"),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+        let position_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("camera-position-layout"),
+                entries: &[wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::VERTEX,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                }],
+            });
+        let position_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &position_bind_group_layout,
+            label: Some("camera-position-layout"),
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: position_buffer.as_entire_binding(),
+            }],
+        });
+
         Self {
+            position_bind_group_layout,
+            position_bind_group,
+            position_buffer,
             aspect_ratio: surface_width / surface_height,
+            device,
+            queue,
             eye,
             yaw,
             pitch,
-
             fovy: consts::FRAC_PI_4,
             znear: 0.1,
             zfar: 1000.,

src/shaders/shader.wgsl

@@ -20,7 +20,8 @@ struct VertexOutput {
     @location(1) normals: vec3<f32>,
     @location(2) chunk_position: vec2<i32>,
     @location(3) block_type: u32,
-    @location(4) ao: f32
+    @location(4) ao: f32,
+    @location(5) fog: f32
 }
 
 
@@ -30,16 +31,22 @@ var<uniform> projection: mat4x4<f32>;
 var<uniform> view: mat4x4<f32>;
 @group(2) @binding(0)
 var <uniform> current_chunk: vec2<i32>;
+@group(3) @binding(0)
+var <uniform> player_position: vec3<f32>;
 
 
 @vertex
 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);
+    let chunk_offset = vec3<f32>(f32(current_chunk.x) * 16.0, 0.0, f32(current_chunk.y) * 16.0);
+    let block_position = in.position + chunk_offset;
 
-    out.clip_position = projection * view * (vec4<f32>(in.position.xyz, 1.0) + chunk_offset);
+    let player_dist = distance(player_position, block_position);
+
+    out.fog = min(pow(player_dist / 80.0, 6.0), 1.0);
+    out.clip_position = projection * view * (vec4<f32>(block_position, 1.0));
     out.normals = in.normal;
     out.tex_coords = in.tex_coords;
     out.ao = in.ao;
@@ -58,7 +65,8 @@ struct FragmentInput {
         @location(1) normals: vec3<f32>,
         @location(2) current_chunk: vec2<i32>,
         @location(3) block_type: u32,
-        @location(4) ao: f32
+        @location(4) ao: f32,
+        @location(5) fog: f32
 }
 
 const light_direction = vec3<f32>(0.25, 1.0, -0.5);
@@ -72,6 +80,7 @@ fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {
     color *= max(dot(in.normals, normalize(light_direction)), 0.2);
     color += vec4<f32>(vec3<f32>(ambient_light), 0.0);
     color *= 1.0 - (in.ao * 0.9);
+    color = mix(color, vec4<f32>(0.1, 0.2, 0.3, 1.0), in.fog);
 
     return color;
 }

src/state.rs

@@ -66,10 +66,16 @@ impl State {
             view_formats: vec![],
         };
 
-        let camera = Camera::new(surface_config.width as f32, surface_config.height as f32);
+        let camera = Camera::new(
+            surface_config.width as f32,
+            surface_config.height as f32,
+            device.clone(),
+            queue.clone(),
+        );
+        let current_chunk = camera.eye.get_chunk_from_position_absolute();
         let player = Arc::new(RwLock::new(Player {
             camera,
-            current_chunk: (0, 0),
+            current_chunk,
             is_jumping: false,
             on_ground: false,
             facing_block: None,
@@ -84,7 +90,7 @@ impl State {
         };
 
         let mut world = World::init_world(device.clone(), queue.clone());
-        world.init_chunks();
+        world.init_chunks(Arc::clone(&player));
         let ui = UI::new(device.clone(), queue.clone());
 
         let mut state = Self {
@@ -254,6 +260,7 @@ impl State {
             delta_time,
             &collisions,
         );
+        player.update();
         if let Some((block, face_dir)) = player.get_facing_block(&collisions) {
             let block = self.world.get_blocks_absolute(&block.to_block_position());
 
@@ -309,6 +316,8 @@ impl State {
             .map(|f| f.read().unwrap())
             .collect::<Vec<_>>();
 
+        let player = self.player.read().unwrap();
+
         {
             let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: None,
@@ -343,6 +352,8 @@ impl State {
             rpass.set_bind_group(0, pipeline.bind_group_0(), &[]);
             rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
 
+            rpass.set_bind_group(3, &player.camera.position_bind_group, &[]);
+
             for chunk in chunks.iter() {
                 if chunk.visible {
                     rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);

src/world.rs

@@ -317,7 +317,7 @@ impl World {
                     sender.send(()).unwrap();
                 });
             }
-            for _ in self.chunks.iter(){
+            for _ in self.chunks.iter() {
                 receiver.recv().unwrap();
             }
         }
@@ -332,12 +332,13 @@ impl World {
             chunkbrw.save().expect("failed to save");
         }
     }
-    pub fn init_chunks(&mut self) {
+    pub fn init_chunks(&mut self, player: Arc<RwLock<Player>>) {
         let (sender, receiver) = mpsc::channel();
+        let player = player.read().unwrap();
 
         let mut chunks = vec![];
-        for chunk_x in LB..=UB {
-            for chunk_y in LB..=UB {
+        for chunk_x in LB + player.current_chunk.0..=UB + player.current_chunk.0 {
+            for chunk_y in LB + player.current_chunk.1..=UB + player.current_chunk.1 {
                 let sender = sender.clone();
                 let noise_data = Arc::clone(&self.noise_data);
                 let chunk_data_layout = Arc::clone(&self.chunk_data_layout);