feat: pipeline handle rework

Author: syntaxerror-9

src/main.rs

@@ -38,12 +38,11 @@ pub mod macros;
 pub mod material;
 pub mod persistence;
 pub mod pipeline;
+pub mod pipelines;
 pub mod player;
 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) {
@@ -69,8 +68,6 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
 
     event_loop
         .run(move |event, target| {
-            // let _ = &(instance, &adapter, &shader, pipeline_layout);
-
             if let Event::WindowEvent {
                 window_id: _,
                 event,
@@ -113,10 +110,6 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                             cursor_in = true;
                         }
 
-                        let delta = glam::vec2(
-                            prev_mouse_pos.x - position.x as f32,
-                            prev_mouse_pos.y - position.y as f32,
-                        );
                         prev_mouse_pos.x = position.x as f32;
                         prev_mouse_pos.y = position.y as f32;
 

src/pipeline.rs

@@ -13,11 +13,6 @@ use crate::{
     state::State,
 };
 
-struct Matrices {
-    view: glam::Mat4,
-    projection: glam::Mat4,
-}
-
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Pod, Zeroable)]
 pub struct Uniforms {
@@ -33,284 +28,3 @@ impl From<&Camera> for Uniforms {
         }
     }
 }
-
-pub struct MainPipeline {
-    pub projection_buffer: wgpu::Buffer,
-    pub view_buffer: wgpu::Buffer,
-    pub pipeline: wgpu::RenderPipeline,
-    pub bind_group_0: wgpu::BindGroup,
-    pub bind_group_0_layout: wgpu::BindGroupLayout,
-    pub bind_group_1: wgpu::BindGroup,
-    pub bind_group_1_layout: wgpu::BindGroupLayout,
-    pub depth_texture: Texture,
-    pub pipeline_type: PipelineType,
-}
-
-impl MainPipeline {
-    pub fn new(state: &State) -> Self {
-        let swapchain_capabilities = state.surface.get_capabilities(&state.adapter);
-        let swapchain_format = swapchain_capabilities.formats[0];
-
-        let shader_source = include_str!("./shaders/shader.wgsl");
-
-        let shader = state
-            .device
-            .create_shader_module(wgpu::ShaderModuleDescriptor {
-                label: None,
-                source: wgpu::ShaderSource::Wgsl(shader_source.into()),
-            });
-        let camera = &state.player.read().unwrap().camera;
-        let uniforms = Uniforms::from(camera);
-
-        let projection_buffer =
-            state
-                .device
-                .create_buffer_init(&wgpu::util::BufferInitDescriptor {
-                    label: Some("projection_matrix"),
-                    contents: bytemuck::cast_slice(&[uniforms.projection]),
-                    usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                });
-
-        // View matrix
-        let view_buffer = state
-            .device
-            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
-                label: Some("projection_matrix"),
-                contents: bytemuck::cast_slice(&[uniforms.view]),
-                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
-                .device
-                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                    label: Some("bind_group_0"),
-                    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,
-                        },
-                        wgpu::BindGroupLayoutEntry {
-                            binding: 1,
-                            visibility: wgpu::ShaderStages::VERTEX,
-                            ty: wgpu::BindingType::Buffer {
-                                ty: wgpu::BufferBindingType::Uniform,
-                                has_dynamic_offset: false,
-                                min_binding_size: None,
-                            },
-                            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 {
-            layout: &bind_group_0_layout,
-            label: None,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: projection_buffer.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: view_buffer.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: world_chunk_per_row_buffer.as_entire_binding(),
-                },
-            ],
-        });
-
-        let texture_atlas = Texture::from_path(
-            "assets/tex_atlas.png",
-            "tex_atlas".to_string(),
-            &state.device,
-            &state.queue,
-        )
-        .unwrap();
-
-        let bind_group_1_layout =
-            state
-                .device
-                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                    label: Some("bind_group_1"),
-                    entries: &[
-                        wgpu::BindGroupLayoutEntry {
-                            binding: 0,
-                            visibility: wgpu::ShaderStages::FRAGMENT,
-                            ty: wgpu::BindingType::Texture {
-                                sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                                view_dimension: wgpu::TextureViewDimension::D2,
-                                multisampled: false,
-                            },
-                            count: None,
-                        },
-                        wgpu::BindGroupLayoutEntry {
-                            binding: 1,
-                            visibility: wgpu::ShaderStages::FRAGMENT,
-                            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                            count: None,
-                        },
-                    ],
-                });
-
-        let bind_group_1 = state.device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("bind_group_1"),
-            layout: &bind_group_1_layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(&texture_atlas.view),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&texture_atlas.sampler),
-                },
-            ],
-        });
-
-        // Textures
-        let depth_texture = Texture::create_depth_texture(state);
-
-        // Pipeline layouts
-        let pipeline_layout =
-            state
-                .device
-                .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                    label: None,
-                    bind_group_layouts: &[
-                        &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: &[],
-                });
-
-        let render_pipeline =
-            state
-                .device
-                .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                    label: None,
-                    layout: Some(&pipeline_layout),
-                    vertex: wgpu::VertexState {
-                        module: &shader,
-                        entry_point: "vs_main",
-                        buffers: &[Block::get_vertex_data_layout()],
-                    },
-                    fragment: Some(wgpu::FragmentState {
-                        module: &shader,
-                        entry_point: "fs_main",
-                        targets: &[Some(swapchain_format.into())],
-                    }),
-
-                    primitive: wgpu::PrimitiveState {
-                        polygon_mode: state.config.polygon_mode,
-                        cull_mode: Some(Face::Front),
-                        ..Default::default()
-                    },
-                    depth_stencil: Some(wgpu::DepthStencilState {
-                        format: Texture::DEPTH_FORMAT,
-                        depth_write_enabled: true,
-                        depth_compare: wgpu::CompareFunction::Less,
-                        stencil: wgpu::StencilState::default(),
-                        bias: wgpu::DepthBiasState::default(),
-                    }),
-                    multisample: wgpu::MultisampleState::default(),
-                    multiview: None,
-                });
-
-        Self {
-            bind_group_0_layout,
-            bind_group_1_layout,
-            view_buffer,
-            projection_buffer,
-            pipeline_type: PipelineType::WORLD,
-            depth_texture,
-            bind_group_0,
-            bind_group_1,
-            pipeline: render_pipeline,
-        }
-    }
-}
-
-impl PipelineTrait for MainPipeline {
-    fn projection_buffer(&self) -> &Buffer {
-        &self.projection_buffer
-    }
-
-    fn pipeline(&self) -> &RenderPipeline {
-        &self.pipeline
-    }
-
-    fn view_buffer(&self) -> &Buffer {
-        &self.view_buffer
-    }
-
-    fn depth_texture(&self) -> &Texture {
-        &self.depth_texture
-    }
-    fn set_depth_texture(&mut self, texture: Texture) {
-        self.depth_texture = texture;
-    }
-    fn bind_group_0(&self) -> &BindGroup {
-        &self.bind_group_0
-    }
-    fn bind_group_1(&self) -> &BindGroup {
-        &self.bind_group_1
-    }
-    fn get_type(&self) -> PipelineType {
-        self.pipeline_type
-    }
-}
-
-pub trait PipelineTrait {
-    fn projection_buffer(&self) -> &wgpu::Buffer;
-    fn pipeline(&self) -> &wgpu::RenderPipeline;
-    fn view_buffer(&self) -> &wgpu::Buffer;
-    fn bind_group_0(&self) -> &wgpu::BindGroup;
-    fn bind_group_1(&self) -> &wgpu::BindGroup;
-    fn depth_texture(&self) -> &Texture;
-    fn set_depth_texture(&mut self, texture: Texture);
-
-    fn get_type(&self) -> PipelineType;
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum PipelineType {
-    WORLD,
-    WATER,
-    UI,
-}