Refine UI panels and render mode flow

src/render.rs

@@ -8,6 +8,7 @@ use eframe::{
     egui_wgpu::{self, wgpu},
     wgpu::util::DeviceExt,
 };
+use std::ops::Range;
 
 pub const PRESSURE_CELL_COUNT: usize =
     (crate::matrix::MATRIX_ROWS * crate::matrix::MATRIX_COLS) as usize;
@@ -17,13 +18,26 @@ pub struct WgpuBackgroundCallback {
     pub width: f32,
     pub height: f32,
     pub pressure: PressureFrame,
-    pub marker_mode: MarkerMode,
+    pub active_mode: ActiveMode,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum MarkerMode {
-    Number,
-    Dot,
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ActiveMode {
+    Finger(FingerMode),
+    Hand(HandGatewayMode),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FingerMode {
+    pub rows: u32,
+    pub cols: u32,
+    pub range: Range<u32>,
+    pub dot: bool,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct HandGatewayMode {
+    pub range: Range<u32>,
 }
 
 impl egui_wgpu::CallbackTrait for WgpuBackgroundCallback {
@@ -36,14 +50,7 @@ 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,
-            self.marker_mode,
-        );
-
+        resources.prepare(queue, self.width, self.height, &self.pressure);
         Vec::new()
     }
 
@@ -54,7 +61,7 @@ impl egui_wgpu::CallbackTrait for WgpuBackgroundCallback {
         resources: &egui_wgpu::CallbackResources,
     ) {
         let resources: &BackgroundRenderResources = resources.get().unwrap();
-        resources.paint(render_pass);
+        resources.paint(render_pass, &self.active_mode);
     }
 }
 
@@ -65,16 +72,17 @@ pub struct BackgroundRenderResources {
     uniform: MatrixUniform,
     uniform_buffer: wgpu::Buffer,
     uniform_bind_group: wgpu::BindGroup,
+
     background_pipeline: wgpu::RenderPipeline,
     glyph_pipeline: wgpu::RenderPipeline,
     dot_pipeline: wgpu::RenderPipeline,
     model_pipeline: wgpu::RenderPipeline,
+
     model: Option<Model>,
     model_instance_buffer: wgpu::Buffer,
     glyph_vertex_buffer: wgpu::Buffer,
     glyph_instance_buffer: wgpu::Buffer,
     glyph_instances: Vec<GlyphInstance>,
-    marker_mode: MarkerMode,
 }
 
 impl BackgroundRenderResources {
@@ -180,10 +188,10 @@ impl BackgroundRenderResources {
             create_model_pipeline(device, target_format, &shader, &model_pipeline_layout);
 
         let model =
-            match resources::load_model("cube.obj", device, _queue, &texture_bind_group_layout) {
+            match resources::load_model("hand.obj", device, _queue, &texture_bind_group_layout) {
                 Ok(model) => Some(model),
                 Err(err) => {
-                    log::warn!("failed to load cube.obj: {err:#}");
+                    log::warn!("failed to load hand.obj: {err:#}");
                     None
                 }
             };
@@ -239,22 +247,13 @@ impl BackgroundRenderResources {
             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,
-        marker_mode: MarkerMode,
-    ) {
+    fn prepare(&mut self, queue: &wgpu::Queue, width: f32, height: f32, pressure: &PressureFrame) {
         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,
@@ -275,12 +274,36 @@ impl BackgroundRenderResources {
         );
     }
 
-    fn paint(&self, render_pass: &mut wgpu::RenderPass<'_>) {
+    fn paint(&self, render_pass: &mut wgpu::RenderPass<'_>, active_mode: &ActiveMode) {
         render_pass.set_bind_group(0, &self.uniform_bind_group, &[]);
 
         render_pass.set_pipeline(&self.background_pipeline);
         render_pass.draw(0..3, 0..1);
 
+        match active_mode {
+            ActiveMode::Finger(mode) => self.paint_finger(render_pass, mode),
+            ActiveMode::Hand(mode) => self.paint_hand(render_pass, mode),
+        }
+    }
+
+    fn paint_finger(&self, render_pass: &mut wgpu::RenderPass<'_>, mode: &FingerMode) {
+        let _range = mode.range.clone();
+        let marker_pipeline = if mode.dot {
+            &self.dot_pipeline
+        } else {
+            &self.glyph_pipeline
+        };
+        let draw_count = self.visible_instance_count(mode.rows, mode.cols);
+
+        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..draw_count);
+    }
+
+    fn paint_hand(&self, render_pass: &mut wgpu::RenderPass<'_>, mode: &HandGatewayMode) {
+        let _range = mode.range.clone();
+
         if let Some(model) = &self.model {
             render_pass.set_pipeline(&self.model_pipeline);
             render_pass.set_vertex_buffer(1, self.model_instance_buffer.slice(..));
@@ -294,17 +317,11 @@ impl BackgroundRenderResources {
                 render_pass.draw_indexed(0..mesh.num_elements, 0, 0..1);
             }
         }
+    }
 
-        // 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);
+    fn visible_instance_count(&self, rows: u32, cols: u32) -> u32 {
+        let requested = rows.saturating_mul(cols);
+        requested.min(self.glyph_instances.len() as u32)
     }
 }