feat: water init

Author: syntaxerror-9

src/chunk.rs

@@ -28,6 +28,7 @@ pub struct Chunk {
     pub y: i32,
     pub blocks: BlockVec,
     pub indices: u32,
+    pub water_indices: u32,
     pub device: Arc<wgpu::Device>,
     pub queue: Arc<wgpu::Queue>,
     pub noise_data: Arc<NoiseData>,
@@ -122,7 +123,22 @@ impl Chunk {
             false
         }
     }
-    pub fn build_mesh(&self, other_chunks: Vec<WorldChunk>) -> (u32, wgpu::Buffer, wgpu::Buffer) {
+    /*
+    Return tuple:
+    0: vertex indices     , 1: water vertex indices
+    2: vertex buffer      , 3: index buffer
+    4: water vertex buffer, 5: water index buffer */
+    pub fn build_mesh(
+        &self,
+        other_chunks: Vec<WorldChunk>,
+    ) -> (
+        u32,
+        u32,
+        wgpu::Buffer,
+        wgpu::Buffer,
+        wgpu::Buffer,
+        wgpu::Buffer,
+    ) {
         let mut water_vertex: Vec<BlockVertexData> = vec![];
         let mut water_indices: Vec<u32> = vec![];
         let mut vertex: Vec<BlockVertexData> = vec![];
@@ -176,6 +192,13 @@ impl Chunk {
                                     let chunk = chunk.read().unwrap();
                                     if chunk.exists_block_at(&target_block) {
                                         is_visible = false;
+
+                                        if chunk.block_type_at(&target_block)
+                                            == Some(BlockType::Water)
+                                            && block.block_type != BlockType::Water
+                                        {
+                                            is_visible = true;
+                                        }
                                     }
                                 }
                                 None => {
@@ -187,15 +210,21 @@ impl Chunk {
                                             target_block.z as u32,
                                             self.noise_data.clone(),
                                         )
+                                        && face_position.y >= WATER_HEIGHT_LEVEL as f32
                                     {
                                         is_visible = false
                                     };
                                 }
                             }
-                        } else if self.exists_block_at(&face_position)
-                            && self.block_type_at(&face_position) != Some(BlockType::Water)
-                        {
+                        } else if self.exists_block_at(&face_position) {
                             is_visible = false;
+
+                            // This can be a oneline if, but it gets very hard to read
+                            if self.block_type_at(&face_position) == Some(BlockType::Water)
+                                && block.block_type != BlockType::Water
+                            {
+                                is_visible = true;
+                            }
                         }
 
                         if is_visible {
@@ -244,10 +273,28 @@ impl Chunk {
                     usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
                 });
 
+        let chunk_water_vertex_buffer =
+            self.device
+                .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    contents: bytemuck::cast_slice(&water_vertex),
+                    label: Some(&format!("water-chunk-vertex-{}-{}", self.x, self.y)),
+                    usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+                });
+        let chunk_water_index_buffer =
+            self.device
+                .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    contents: bytemuck::cast_slice(&water_indices),
+                    label: Some(&format!("water-chunk-vertex-{}-{}", self.x, self.y)),
+                    usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
+                });
+
         (
             indices.len() as u32,
+            water_indices.len() as u32,
             chunk_vertex_buffer,
             chunk_index_buffer,
+            chunk_water_vertex_buffer,
+            chunk_water_index_buffer,
         )
     }
     pub fn get_bind_group_layout() -> wgpu::BindGroupLayoutDescriptor<'static> {
@@ -477,6 +524,7 @@ impl Chunk {
             chunk_bind_group,
             chunk_position_buffer,
             indices: 0,
+            water_indices: 0,
             outside_blocks: vec![],
             visible: true,
         };

src/main.rs

@@ -43,6 +43,7 @@ pub mod state;
 pub mod structures;
 pub mod ui;
 pub mod utils;
+mod water;
 pub mod world;
 
 async fn run(event_loop: EventLoop<()>, window: Window) {

src/pipeline.rs

@@ -173,7 +173,12 @@ impl Pipeline {
                         &bind_group_0_layout,
                         &bind_group_1_layout,
                         &state.world.chunk_data_layout,
-                        &state.player.read().unwrap().camera.position_bind_group_layout
+                        &state
+                            .player
+                            .read()
+                            .unwrap()
+                            .camera
+                            .position_bind_group_layout,
                     ],
                     push_constant_ranges: &[],
                 });
@@ -268,6 +273,7 @@ pub trait PipelineTrait {
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum PipelineType {
     WORLD,
+    WATER,
     UI,
 }
 

src/shaders/shader.wgsl

@@ -80,7 +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);
+    color = mix(color, vec4<f32>(0.03, 0.64, 0.97, 1.0), in.fog);
 
     return color;
 }

src/shaders/water_shader.wgsl

@@ -0,0 +1,80 @@
+
+
+struct VertexInput {
+    @builtin(vertex_index) vertex_index: u32,
+    @location(0) position: vec3<f32>,
+    @location(1) normal: vec3<f32>,
+    @location(2) tex_coords: vec2<f32>,
+    @location(3) ao: f32,
+
+}
+struct InstanceInput {
+    // @location(2) instance_transform: vec3<f32>,
+    @builtin(instance_index) instance_index: u32,
+};
+
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+    @location(1) normals: vec3<f32>,
+    @location(2) chunk_position: vec2<i32>,
+    @location(3) block_type: u32,
+    @location(4) ao: f32,
+    @location(5) fog: f32
+}
+
+
+@group(0) @binding(0)
+var<uniform> projection: mat4x4<f32>;
+@group(0) @binding(1)
+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 = vec3<f32>(f32(current_chunk.x) * 16.0, 0.0, f32(current_chunk.y) * 16.0);
+    let block_position = in.position + 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;
+
+    return out;
+}
+
+
+@group(1) @binding(0)
+var diffuse: texture_2d<f32>;
+@group(1) @binding(1)
+var t_sampler: sampler;
+
+struct FragmentInput {
+        @location(0) tex_coords: vec2<f32>,
+        @location(1) normals: vec3<f32>,
+        @location(2) current_chunk: vec2<i32>,
+        @location(3) block_type: u32,
+        @location(4) ao: f32,
+        @location(5) fog: f32
+}
+
+
+@fragment
+fn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {
+    var color: vec4<f32>;
+    color = textureSample(diffuse, t_sampler, in.tex_coords);
+    color.a = 0.1;
+
+    return color;
+}

src/state.rs

@@ -7,6 +7,7 @@ use crate::collision::CollisionBox;
 use crate::persistence::Saveable;
 use crate::pipeline::{Pipeline, PipelineTrait};
 use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
+use crate::water::WaterPipeline;
 use crate::{
     material::Texture,
     pipeline::{self, Uniforms},
@@ -110,9 +111,11 @@ impl State {
         };
 
         let world_pipeline = Box::new(Pipeline::new(&state));
+        let water_pipeline = Box::new(WaterPipeline::new(&state));
         let ui_pipeline = Box::new(UIPipeline::new(&state));
 
         state.pipelines.push(world_pipeline);
+        state.pipelines.push(water_pipeline);
         state.pipelines.push(ui_pipeline);
 
         state
@@ -326,9 +329,9 @@ impl State {
                     resolve_target: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color {
-                            r: 0.1,
-                            g: 0.2,
-                            b: 0.3,
+                            r: 0.03,
+                            g: 0.64,
+                            b: 0.97,
                             a: 1.0,
                         }),
                         store: wgpu::StoreOp::Store,
@@ -377,6 +380,59 @@ impl State {
                 };
             }
         }
+        {
+            let mut water_rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Load,
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &self.pipelines[0].depth_texture().view,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Load,
+                        store: wgpu::StoreOp::Discard,
+                    }),
+                    stencil_ops: None,
+                }),
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+            let pipeline = &self.pipelines[1];
+
+            water_rpass.set_pipeline(pipeline.pipeline());
+
+            water_rpass.set_bind_group(0, pipeline.bind_group_0(), &[]);
+            water_rpass.set_bind_group(1, pipeline.bind_group_1(), &[]);
+            water_rpass.set_bind_group(3, &player.camera.position_bind_group, &[]);
+
+            for chunk in chunks.iter() {
+                if chunk.visible {
+                    water_rpass.set_bind_group(2, &chunk.chunk_bind_group, &[]);
+                    water_rpass.set_vertex_buffer(
+                        0,
+                        chunk
+                            .chunk_water_vertex_buffer
+                            .as_ref()
+                            .expect("Vertex buffer not initiated")
+                            .slice(..),
+                    );
+                    water_rpass.set_index_buffer(
+                        chunk
+                            .chunk_water_index_buffer
+                            .as_ref()
+                            .expect("Index buffer not initiated")
+                            .slice(..),
+                        wgpu::IndexFormat::Uint32,
+                    );
+                    water_rpass.draw_indexed(0..chunk.water_indices, 0, 0..1);
+                };
+            }
+        }
         {
             let mut ui_renderpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: None,
@@ -400,7 +456,7 @@ impl State {
                 occlusion_query_set: None,
             });
 
-            let pipeline = &self.pipelines[1];
+            let pipeline = &self.pipelines[2];
             ui_renderpass.set_pipeline(pipeline.pipeline());
 
             ui_renderpass.set_bind_group(0, pipeline.bind_group_0(), &[]);