fog based on render dist

Author: syntaxerror-9

src/pipeline.rs

@@ -68,6 +68,16 @@ impl Pipeline {
                 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             });
 
+        // Constant bindgroup for chunks per row
+        let world_chunk_per_row_buffer =
+            state
+                .device
+                .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    contents: bytemuck::cast_slice(&[crate::world::CHUNKS_PER_ROW]),
+                    label: Some("world_chunk_per_row"),
+                    usage: wgpu::BufferUsages::UNIFORM,
+                });
+
         // Bind groups
         let bind_group_0_layout =
             state
@@ -95,6 +105,16 @@ impl Pipeline {
                             },
                             count: None,
                         },
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 2,
+                            visibility: wgpu::ShaderStages::VERTEX,
+                            ty: wgpu::BindingType::Buffer {
+                                ty: wgpu::BufferBindingType::Uniform,
+                                has_dynamic_offset: false,
+                                min_binding_size: None,
+                            },
+                            count: None,
+                        },
                     ],
                 });
         let bind_group_0 = state.device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -109,6 +129,10 @@ impl Pipeline {
                     binding: 1,
                     resource: view_buffer.as_entire_binding(),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: world_chunk_per_row_buffer.as_entire_binding(),
+                },
             ],
         });
 

src/shaders/shader.wgsl

@@ -29,6 +29,9 @@ struct VertexOutput {
 var<uniform> projection: mat4x4<f32>;
 @group(0) @binding(1) 
 var<uniform> view: mat4x4<f32>;
+@group(0) @binding(2)
+var <uniform> chunks_per_row: u32;
+
 @group(2) @binding(0)
 var <uniform> current_chunk: vec2<i32>;
 @group(3) @binding(0)
@@ -45,7 +48,10 @@ fn vs_main(in: VertexInput, instance_data: InstanceInput) -> VertexOutput {
 
     let player_dist = distance(player_position, block_position);
 
-    out.fog = min(pow(player_dist / 80.0, 6.0), 1.0);
+    let r = f32(16 * (i32(chunks_per_row) / 2));
+    out.fog = clamp((player_dist - r) / 8.0, 0.0, 1.0);
+
+    // 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;

src/shaders/water_shader.wgsl

@@ -5,7 +5,6 @@ struct VertexInput {
     @location(0) position: vec3<f32>,
     @location(1) normal: vec3<f32>,
     @location(2) tex_coords: vec2<f32>,
-    @location(3) ao: f32,
 
 }
 struct InstanceInput {
@@ -20,15 +19,16 @@ struct VertexOutput {
     @location(1) normals: vec3<f32>,
     @location(2) chunk_position: vec2<i32>,
     @location(3) block_type: u32,
-    @location(4) ao: f32,
-    @location(5) fog: f32
+    @location(4) fog: f32
 }
 
 
 @group(0) @binding(0)
 var<uniform> projection: mat4x4<f32>;
 @group(0) @binding(1)
 var<uniform> view: mat4x4<f32>;
+@group(0) @binding(2)
+var <uniform> chunks_per_row: u32;
 @group(2) @binding(0)
 var <uniform> current_chunk: vec2<i32>;
 @group(3) @binding(0)
@@ -45,11 +45,12 @@ fn vs_main(in: VertexInput, instance_data: InstanceInput) -> VertexOutput {
 
     let player_dist = distance(player_position, block_position);
 
-    out.fog = min(pow(player_dist / 80.0, 6.0), 1.0);
+    let r = f32(16 * (i32(chunks_per_row) / 2));
+    out.fog = clamp((player_dist - r) / 8.0, 0.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;
 
     return out;
 }
@@ -65,8 +66,7 @@ struct FragmentInput {
         @location(1) normals: vec3<f32>,
         @location(2) current_chunk: vec2<i32>,
         @location(3) block_type: u32,
-        @location(4) ao: f32,
-        @location(5) fog: f32
+        @location(4) fog: f32
 }
 
 
@@ -75,6 +75,8 @@ fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {
     var color: vec4<f32>;
     color = textureSample(diffuse, t_sampler, in.tex_coords);
     color.a = 0.6;
+    color = mix(color, vec4<f32>(0.03, 0.64, 0.97, 1.0), in.fog);
+
 
     return color;
 }

src/state.rs

@@ -322,7 +322,7 @@ impl State {
         let player = self.player.read().unwrap();
 
         {
-            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            let mut main_rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: None,
                 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                     view: &view,
@@ -350,33 +350,33 @@ impl State {
             });
             let pipeline = &self.pipelines[0];
 
-            rpass.set_pipeline(pipeline.pipeline());
+            main_rpass.set_pipeline(pipeline.pipeline());
 
-            rpass.set_bind_group(0, pipeline.bind_group_0(), &[]);
-            rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
+            main_rpass.set_bind_group(0, pipeline.bind_group_0(), &[]);
+            main_rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
 
-            rpass.set_bind_group(3, &player.camera.position_bind_group, &[]);
+            main_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, &[]);
-                    rpass.set_vertex_buffer(
+                    main_rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);
+                    main_rpass.set_vertex_buffer(
                         0,
                         chunk
                             .chunk_vertex_buffer
                             .as_ref()
                             .expect("Vertex buffer not initiated")
                             .slice(..),
                     );
-                    rpass.set_index_buffer(
+                    main_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);
+                    main_rpass.draw_indexed(0..chunk.indices, 0, 0..1);
                 };
             }
         }

src/water.rs

@@ -23,7 +23,7 @@ pub struct WaterPipeline {
     pub pipeline_type: crate::pipeline::PipelineType,
 }
 impl WaterPipeline {
-    // TODO: This is very ugly and should be abstracted for all pipelines
+    // TODO: This is very ugly and should be abstracted for all pipelines. Also doubles the resource for uniforms etc.
     pub fn new(state: &State) -> Self {
         let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
         let swapchain_format = swapchain_capabilities.formats[0];
@@ -57,6 +57,16 @@ impl WaterPipeline {
                 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             });
 
+        // Constant bindgroup for chunks per row
+        let world_chunk_per_row_buffer =
+            state
+                .device
+                .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    contents: bytemuck::cast_slice(&[crate::world::CHUNKS_PER_ROW]),
+                    label: Some("world_chunk_per_row"),
+                    usage: wgpu::BufferUsages::UNIFORM,
+                });
+
         // Bind groups
         let bind_group_0_layout =
             state
@@ -84,6 +94,16 @@ impl WaterPipeline {
                             },
                             count: None,
                         },
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 2,
+                            visibility: wgpu::ShaderStages::VERTEX,
+                            ty: wgpu::BindingType::Buffer {
+                                ty: wgpu::BufferBindingType::Uniform,
+                                has_dynamic_offset: false,
+                                min_binding_size: None,
+                            },
+                            count: None,
+                        },
                     ],
                 });
         let bind_group_0 = state.device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -98,6 +118,10 @@ impl WaterPipeline {
                     binding: 1,
                     resource: view_buffer.as_entire_binding(),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: world_chunk_per_row_buffer.as_entire_binding(),
+                },
             ],
         });
 

src/world.rs

@@ -6,6 +6,8 @@ use std::{
     sync::{mpsc, Arc},
     thread,
 };
+use wgpu::util::DeviceExt;
+use wgpu::BindGroupEntry;
 
 use crate::blocks::block_type::BlockType;
 use crate::persistence::Saveable;
@@ -18,8 +20,8 @@ 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;
-// There will be a CHUNKS_PER_ROW * CHUNKS_PER_ROW region
-pub const CHUNKS_PER_ROW: u32 = 15;
+
+pub const CHUNKS_PER_ROW: u32 = 25;
 pub const CHUNKS_REGION: u32 = CHUNKS_PER_ROW * CHUNKS_PER_ROW;
 pub const WATER_HEIGHT_LEVEL: u8 = 5;