refactor: 迁移 shader.wgsl 至 static/wgsl/，新增 model 模块

src/render.rs

@@ -14,6 +14,13 @@ pub struct WgpuBackgroundCallback {
     pub width: f32,
     pub height: f32,
     pub pressure: PressureFrame,
+    pub marker_mode: MarkerMode,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum MarkerMode {
+    Number,
+    Dot,
 }
 
 impl egui_wgpu::CallbackTrait for WgpuBackgroundCallback {
@@ -26,7 +33,13 @@ impl egui_wgpu::CallbackTrait for WgpuBackgroundCallback {
         resources: &mut egui_wgpu::CallbackResources,
     ) -> Vec<wgpu::CommandBuffer> {
         let resources: &mut BackgroundRenderResources = resources.get_mut().unwrap();
-        resources.prepare(queue, self.width, self.height, &self.pressure);
+        resources.prepare(
+            queue,
+            self.width,
+            self.height,
+            &self.pressure,
+            self.marker_mode,
+        );
 
         Vec::new()
     }
@@ -51,9 +64,11 @@ pub struct BackgroundRenderResources {
     uniform_bind_group: wgpu::BindGroup,
     background_pipeline: wgpu::RenderPipeline,
     glyph_pipeline: wgpu::RenderPipeline,
+    dot_pipeline: wgpu::RenderPipeline,
     glyph_vertex_buffer: wgpu::Buffer,
     glyph_instance_buffer: wgpu::Buffer,
     glyph_instances: Vec<GlyphInstance>,
+    marker_mode: MarkerMode,
 }
 
 impl BackgroundRenderResources {
@@ -96,10 +111,20 @@ impl BackgroundRenderResources {
         });
 
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Pressure Matrix Shader"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
+            label: Some("Pressure Matrix Background Shader"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("../static/wgsl/shader.wgsl").into()),
         });
 
+        // let glyph_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        //     label: Some("Pressure Matrix Glyph Shader"),
+        //     source: wgpu::ShaderSource::Wgsl(include_str!("../static/wgsl/shader.wgsl").into()),
+        // });
+
+        // let dot_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        //     label: Some("Pressure Matrix Dot Shader"),
+        //     source: wgpu::ShaderSource::Wgsl(include_str!("../static/wgsl/shader.wgsl").into()),
+        // });
+
         let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
             label: Some("Pressure Matrix Pipeline Layout"),
             bind_group_layouts: &[Some(&uniform_bind_group_layout)],
@@ -110,6 +135,8 @@ impl BackgroundRenderResources {
             create_background_pipeline(device, target_format, &shader, &pipeline_layout);
         let glyph_pipeline =
             create_glyph_pipeline(device, target_format, &shader, &pipeline_layout);
+        let dot_pipeline =
+            create_dot_pipeline(device, target_format, &shader, &pipeline_layout);
 
         let glyph_vertices = [
             GlyphVertex {
@@ -144,16 +171,26 @@ impl BackgroundRenderResources {
             uniform_bind_group,
             background_pipeline,
             glyph_pipeline,
+            dot_pipeline,
             glyph_vertex_buffer,
             glyph_instance_buffer,
             glyph_instances,
+            marker_mode: MarkerMode::Number,
         }
     }
 
-    fn prepare(&mut self, queue: &wgpu::Queue, width: f32, height: f32, pressure: &PressureFrame) {
+    fn prepare(
+        &mut self,
+        queue: &wgpu::Queue,
+        width: f32,
+        height: f32,
+        pressure: &PressureFrame,
+        marker_mode: MarkerMode,
+    ) {
         let aspect = width / height.max(1.0);
         self.uniform =
             MatrixUniform::new(width, height, build_view_projection(aspect, &self.layout));
+        self.marker_mode = marker_mode;
         queue.write_buffer(
             &self.uniform_buffer,
             0,
@@ -180,7 +217,13 @@ impl BackgroundRenderResources {
         render_pass.set_pipeline(&self.background_pipeline);
         render_pass.draw(0..3, 0..1);
 
-        render_pass.set_pipeline(&self.glyph_pipeline);
+        // let marker_pipeline = match self.marker_mode {
+        //     MarkerMode::Number => &self.glyph_pipeline,
+        //     MarkerMode::Dot => &self.dot_pipeline,
+        // };
+        let marker_pipeline = &self.dot_pipeline;
+
+        render_pass.set_pipeline(marker_pipeline);
         render_pass.set_vertex_buffer(0, self.glyph_vertex_buffer.slice(..));
         render_pass.set_vertex_buffer(1, self.glyph_instance_buffer.slice(..));
         render_pass.draw(0..6, 0..self.glyph_instances.len() as u32);
@@ -253,6 +296,39 @@ fn create_glyph_pipeline(
     })
 }
 
+fn create_dot_pipeline(
+    device: &wgpu::Device,
+    target_format: &wgpu::TextureFormat,
+    shader: &wgpu::ShaderModule,
+    layout: &wgpu::PipelineLayout,
+) -> wgpu::RenderPipeline {
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Pressure Matrix Dot Pipeline"),
+        layout: Some(layout),
+        vertex: wgpu::VertexState {
+            module: shader,
+            entry_point: Some("vs_dot"),
+            compilation_options: Default::default(),
+            buffers: &[GlyphVertex::desc(), GlyphInstance::desc()],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: shader,
+            entry_point: Some("fs_dot"),
+            compilation_options: Default::default(),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: *target_format,
+                blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        primitive: wgpu::PrimitiveState::default(),
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        multiview_mask: None,
+        cache: None,
+    })
+}
+
 fn build_glyph_instances(
     rows: u32,
     cols: u32,