Refine finger mode UI: app wiring, style helpers, and panel layout

src/app.rs

@@ -3,26 +3,29 @@ use crate::connection::ConnectionManager;
 use crate::force::{ForceEstimatorState, HudSpatialForce};
 use crate::recording::Recorder;
 use crate::render::{ActiveMode, FingerMode, HandGatewayMode};
-use crate::style::{self, ONE_DARK_PRO, apply_fonts, apply_theme, dim_text, layout};
+use crate::style::{ONE_DARK_PRO, apply_fonts, apply_theme, layout};
 use crate::ui::SerialMode;
 use crate::{
-    matrix::{MATRIX_COLS, MATRIX_ROWS, UNFOLDED_SENSOR_SEGMENT_COUNTS},
+    matrix::{MATRIX_COLS, MATRIX_ROWS},
     render::{
         BackgroundRenderResources, PRESSURE_CELL_COUNT, PressureFrame, PressureSamples,
         WgpuBackgroundCallback,
     },
     ui::{
         ConfigPanelState, ConnectPanelState, FloatingPanelState, MatrixConfigState,
-        draw_config_panel, draw_export_panel, draw_hand_force_panels, draw_stats_panel,
+        draw_config_panel, draw_spatial_force_panel, draw_stats_panel, panel_restore_item,
-        panel_restore_item,
     },
 };
 use eframe::{egui, egui_wgpu};
-use std::sync::Arc;
+use std::{
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 const SUMMARY_POINTS_PER_SERIES: usize = 42;
-const HAND_FORCE_PANEL_COUNT: usize = UNFOLDED_SENSOR_SEGMENT_COUNTS.len();
+const HAND_FORCE_PANEL_COUNT: usize = 7;
-const HAND_FORCE_SEGMENT_COUNTS: [usize; HAND_FORCE_PANEL_COUNT] = UNFOLDED_SENSOR_SEGMENT_COUNTS;
+const HAND_FORCE_SEGMENT_COUNTS: [usize; HAND_FORCE_PANEL_COUNT] = [84, 84, 84, 84, 84, 70, 44];
+const RATE_UPDATE_INTERVAL: Duration = Duration::from_millis(500);
 
 pub struct EskinDesktopApp {
     connect_panel: FloatingPanelState,
@@ -44,16 +47,61 @@ pub struct EskinDesktopApp {
     hand_signal_histories: [Vec<f32>; HAND_FORCE_PANEL_COUNT],
     force_estimator: ForceEstimatorState,
     latest_spatial_force: Option<HudSpatialForce>,
+    spatial_force_panel_force: Option<HudSpatialForce>,
     latest_raw_matrix: Vec<u32>,
     latest_matrix_rows: u32,
     latest_matrix_cols: u32,
     breakout_visible: bool,
     breakout_game: BreakoutGame,
+    live_rates: LiveRateMeters,
     context_menu_open: bool,
     context_menu_pos: egui::Pos2,
     active_mode: ActiveMode,
 }
 
+struct LiveRateMeters {
+    window_started_at: Instant,
+    window_rx_frames: u64,
+    window_render_frames: u32,
+    sample_rate_hz: f32,
+    render_rate_hz: f32,
+}
+
+impl LiveRateMeters {
+    fn new() -> Self {
+        Self {
+            window_started_at: Instant::now(),
+            window_rx_frames: 0,
+            window_render_frames: 0,
+            sample_rate_hz: 0.0,
+            render_rate_hz: 0.0,
+        }
+    }
+
+    fn tick_render(&mut self, total_rx_frames: u64) {
+        if total_rx_frames < self.window_rx_frames {
+            self.window_rx_frames = total_rx_frames;
+            self.sample_rate_hz = 0.0;
+        }
+
+        self.window_render_frames = self.window_render_frames.saturating_add(1);
+
+        let now = Instant::now();
+        let elapsed = now.duration_since(self.window_started_at);
+        if elapsed < RATE_UPDATE_INTERVAL {
+            return;
+        }
+
+        let seconds = elapsed.as_secs_f32().max(0.001);
+        let rx_delta = total_rx_frames.saturating_sub(self.window_rx_frames);
+        self.sample_rate_hz = rx_delta as f32 / seconds;
+        self.render_rate_hz = self.window_render_frames as f32 / seconds;
+        self.window_started_at = now;
+        self.window_rx_frames = total_rx_frames;
+        self.window_render_frames = 0;
+    }
+}
+
 impl EskinDesktopApp {
     pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
         egui_extras::install_image_loaders(&cc.egui_ctx);
@@ -110,11 +158,13 @@ impl EskinDesktopApp {
             hand_signal_histories: std::array::from_fn(|_| Vec::with_capacity(128)),
             force_estimator: ForceEstimatorState::new(),
             latest_spatial_force: None,
+            spatial_force_panel_force: None,
             latest_raw_matrix: Vec::new(),
             latest_matrix_rows: MATRIX_ROWS,
             latest_matrix_cols: MATRIX_COLS,
             breakout_visible: false,
             breakout_game: BreakoutGame::default(),
+            live_rates: LiveRateMeters::new(),
             context_menu_open: false,
             context_menu_pos: egui::pos2(24.0, 48.0),
             active_mode: ActiveMode::Finger(FingerMode {
@@ -159,33 +209,37 @@ impl EskinDesktopApp {
         let color = egui::Color32::from_rgb(255, 196, 54);
         let glow = egui::Color32::from_rgba_unmultiplied(255, 196, 54, 58);
 
-        painter.line_segment([center, end], egui::Stroke::new(9.0_f32, glow));
+        painter.line_segment([center, end], egui::Stroke::new(9.0, glow));
-        painter.line_segment([center, end], egui::Stroke::new(2.4_f32, color));
+        painter.line_segment([center, end], egui::Stroke::new(2.4, color));
         painter.line_segment(
             [end, end - direction * 14.0 + side * 7.0],
-            egui::Stroke::new(2.4_f32, color),
+            egui::Stroke::new(2.4, color),
         );
         painter.line_segment(
             [end, end - direction * 14.0 - side * 7.0],
-            egui::Stroke::new(2.4_f32, color),
+            egui::Stroke::new(2.4, color),
         );
         painter.circle_filled(center, 4.2, color);
     }
 
     fn draw_workspace(&mut self, ui: &mut egui::Ui) {
+        let screen = ui.max_rect();
+        let workspace = egui::Rect::from_min_max(
+            screen.left_top() + egui::vec2(0.0, layout::WORKSPACE_TOP),
+            screen.right_bottom(),
+        );
+
         if self.breakout_visible {
-            self.draw_split_workspace(ui);
+            self.draw_split_workspace(ui, workspace);
         } else {
-            self.draw_wgpu_background_rect(ui, ui.max_rect());
+            ui.painter()
+                .rect_filled(screen, egui::CornerRadius::ZERO, ONE_DARK_PRO.bg);
+            self.draw_wgpu_background_rect(ui, workspace);
         }
     }
 
-    fn draw_split_workspace(&mut self, ui: &mut egui::Ui) {
+    fn draw_split_workspace(&mut self, ui: &mut egui::Ui, content: egui::Rect) {
         let screen = ui.max_rect();
-        let content = egui::Rect::from_min_max(
-            screen.left_top() + egui::vec2(0.0, layout::TITLE_BAR_HEIGHT),
-            screen.right_bottom(),
-        );
         let gutter = 10.0;
         let half_width = (content.width() - gutter).max(1.0) * 0.5;
         let left = egui::Rect::from_min_size(content.min, egui::vec2(half_width, content.height()));
@@ -218,12 +272,6 @@ impl EskinDesktopApp {
 
     fn update_pressure_matrix(&mut self) {
         if let Some(sample) = self.connection.take_latest_sample() {
-            if self.config_state.mode == SerialMode::Finger3D {
-                eprintln!(
-                    "[3d-rawdata] rows={} cols={} values={:?}",
-                    sample.rows, sample.cols, sample.matrix
-                );
-            }
             normalize_pressure_sample(
                 &sample.matrix,
                 sample.rows,
@@ -250,6 +298,10 @@ impl EskinDesktopApp {
             if self.signal_history.len() > SUMMARY_POINTS_PER_SERIES {
                 self.signal_history.remove(0);
             }
+
+            if self.config_state.mode == SerialMode::Hand {
+                update_hand_signal_histories(&mut self.hand_signal_histories, &sample.matrix);
+            }
         }
     }
 
@@ -267,7 +319,7 @@ impl EskinDesktopApp {
         );
         ui.painter().line_segment(
             [title_bar_rect.left_bottom(), title_bar_rect.right_bottom()],
-            egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border),
+            egui::Stroke::new(1.0, ONE_DARK_PRO.border),
         );
 
         // Drag-to-move: double-click to maximize, drag to move
@@ -308,14 +360,14 @@ impl EskinDesktopApp {
                     btn_close_center + egui::vec2(-3.0, -3.0),
                     btn_close_center + egui::vec2(3.0, 3.0),
                 ],
-                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(80, 0, 0)),
+                egui::Stroke::new(1.5, egui::Color32::from_rgb(80, 0, 0)),
             );
             ui.painter().line_segment(
                 [
                     btn_close_center + egui::vec2(3.0, -3.0),
                     btn_close_center + egui::vec2(-3.0, 3.0),
                 ],
-                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(80, 0, 0)),
+                egui::Stroke::new(1.5, egui::Color32::from_rgb(80, 0, 0)),
             );
         }
         if close_resp.clicked() {
@@ -334,7 +386,7 @@ impl EskinDesktopApp {
                     btn_min_center + egui::vec2(-3.0, 0.0),
                     btn_min_center + egui::vec2(3.0, 0.0),
                 ],
-                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(120, 80, 0)),
+                egui::Stroke::new(1.5, egui::Color32::from_rgb(120, 80, 0)),
             );
         }
         if min_resp.clicked() {
@@ -353,7 +405,7 @@ impl EskinDesktopApp {
             ui.painter().rect_stroke(
                 egui::Rect::from_center_size(btn_max_center, egui::vec2(s * 2.0, s * 2.0)),
                 egui::CornerRadius::same(1),
-                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(0, 80, 10)),
+                egui::Stroke::new(1.5, egui::Color32::from_rgb(0, 80, 10)),
                 egui::StrokeKind::Outside,
             );
         }
@@ -369,12 +421,11 @@ impl EskinDesktopApp {
         ctx: &egui::Context,
         stats: crate::serial_core::serial::SerialIoStats,
     ) {
-        // draw_scene_panel(ctx, &mut self.scene_panel);
+        self.scene_panel.visible = false;
-        // if self.config_state.mode == SerialMode::Hand && self.stats_panel.visible {
+        self.connect_panel.visible = false;
-        //     self.config_panel.visible = false;
+        self.export_panel.visible = false;
-        //     self.export_panel.visible = false;
+        self.matrix_config_panel.visible = false;
-        //     self.matrix_config_panel.visible = false;
+        self.context_menu_open = false;
-        // }
 
         if let Some(next_mode) = draw_config_panel(
             ctx,
@@ -383,39 +434,47 @@ impl EskinDesktopApp {
             &self.connection,
             &self.recorder,
             stats,
-            100.0,
+            self.live_rates.sample_rate_hz,
-            100.0,
+            self.live_rates.render_rate_hz,
         ) {
+            if next_mode == SerialMode::Hand {
+                self.config_state.mode = SerialMode::Finger;
+                self.connect_state.mode = SerialMode::Finger;
+                self.config_state.baud_rate = SerialMode::Finger.baud_rate();
+                self.active_mode = ActiveMode::Finger(FingerMode {
+                    rows: self.matrix_config.rows,
+                    cols: self.matrix_config.cols,
+                    range: 0..7000,
+                    dot: true,
+                });
+                self.breakout_visible = true;
+            } else {
                 self.switch_mode(next_mode);
             }
-        match self.config_state.mode {
+        }
-            SerialMode::Finger => {
+
+        if self.breakout_visible {
+            self.stats_panel.visible = false;
+            return;
+        }
+
+        if self.config_state.mode == SerialMode::Finger {
+            self.stats_panel.visible = true;
             draw_stats_panel(
                 ctx,
                 &mut self.stats_panel,
                 &self.signal_history,
                 self.latest_spatial_force,
             );
+        } else {
+            self.stats_panel.visible = false;
         }
-            SerialMode::Finger3D => {
+
-                draw_stats_panel(
+        if let Some(force) = self.latest_spatial_force {
-                    ctx,
+            self.spatial_force_panel_force = Some(force);
-                    &mut self.stats_panel,
-                    &self.signal_history,
-                    self.latest_spatial_force,
-                );
         }
-            SerialMode::Hand => {
+
-                draw_hand_force_panels(ctx, self.stats_panel.visible, &self.hand_signal_histories);
+        draw_spatial_force_panel(ctx, self.spatial_force_panel_force, &self.signal_history);
-            }
-        }
-        draw_export_panel(
-            ctx,
-            &mut self.export_panel,
-            &self.recorder,
-            &mut self.export_path,
-        );
-        // draw_matrix_config_panel(ctx, &mut self.matrix_config_panel, &mut self.matrix_config);
     }
 
     fn draw_panel_context_menu(&mut self, ctx: &egui::Context) {
@@ -508,15 +567,6 @@ impl EskinDesktopApp {
     }
 
     fn switch_mode(&mut self, next: SerialMode) {
-        if next == SerialMode::Finger3D {
-            // The 3D fingertip PCB sends one 12x9 TactileA frame (108 cells).
-            self.matrix_config = MatrixConfigState {
-                rows: 12,
-                cols: 9,
-                color_min: 0.0,
-                color_max: 7000.0,
-            };
-        }
         self.connect_state.mode = next;
         self.config_state.mode = next;
         self.config_state.baud_rate = next.baud_rate();
@@ -525,6 +575,7 @@ impl EskinDesktopApp {
         self.hand_pressure.clear();
         self.force_estimator.reset();
         self.latest_spatial_force = None;
+        self.spatial_force_panel_force = None;
         self.signal_history.clear();
         self.hand_signal_histories
             .iter_mut()
@@ -537,10 +588,8 @@ impl EskinDesktopApp {
                 range: 0..7000,
                 dot: true,
             }),
-            SerialMode::Finger3D | SerialMode::Hand => {
+            SerialMode::Hand => ActiveMode::Hand(HandGatewayMode { range: 0..7000 }),
-                ActiveMode::Hand(HandGatewayMode { range: 0..7000 })
         }
-        };
     }
 }
 
@@ -618,7 +667,7 @@ fn paint_split_viewport_shell(
     painter.rect_stroke(
         rect,
         egui::CornerRadius::same(8),
-        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
         egui::StrokeKind::Outside,
     );
     painter.line_segment(
@@ -626,7 +675,7 @@ fn paint_split_viewport_shell(
             rect.left_top() + egui::vec2(12.0, 34.0),
             rect.right_top() + egui::vec2(-12.0, 34.0),
         ],
-        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
     );
     painter.text(
         rect.left_top() + egui::vec2(14.0, 16.0),
@@ -688,45 +737,16 @@ fn normalize_pressure_value(value: u32) -> [f32; 2] {
     [mapped, display_value]
 }
 
-fn draw_config_bar_mode(ui: &mut egui::Ui, config: &mut ConfigPanelState) -> Option<SerialMode> {
-    let mut changed_to = None;
-
-    ui.horizontal(|ui| {
-        ui.colored_label(dim_text(), "单面指尖");
-        if mode_button(ui, &mut config.mode, SerialMode::Finger, "单面指尖") {
-            changed_to = Some(SerialMode::Finger);
-        }
-    });
-
-    changed_to
-}
-
-fn mode_button(
-    ui: &mut egui::Ui,
-    mode: &mut SerialMode,
-    value: SerialMode,
-    label: &'static str,
-) -> bool {
-    let clicked = ui.add(style::mode_button(label, *mode == value)).clicked();
-
-    if clicked && *mode != value {
-        *mode = value;
-        true
-    } else {
-        false
-    }
-}
-
 impl eframe::App for EskinDesktopApp {
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
         let ctx = ui.ctx().clone();
         let stats = self.connection.stats();
+        self.live_rates.tick_render(stats.rx_frames);
 
         self.update_pressure_matrix();
         self.draw_workspace(ui);
         self.draw_title_bar(ui, frame);
         self.draw_floating_panels(&ctx, stats);
-        self.draw_panel_context_menu(&ctx);
 
         // Keep repainting while the wgpu background is a realtime viewport.
         ctx.request_repaint();

src/breakout.rs

@@ -20,6 +20,7 @@ enum BreakoutPhase {
     Idle,
     Running,
     Paused,
+    Won,
     Over,
 }
 
@@ -46,7 +47,6 @@ pub struct BreakoutGame {
     score: u32,
     combo: u32,
     lives: u32,
-    level: u32,
     last_time: Option<f64>,
     previous_pause_gesture: bool,
     pause_locked_until: f64,
@@ -63,7 +63,6 @@ impl Default for BreakoutGame {
             score: 0,
             combo: 0,
             lives: 3,
-            level: 1,
             last_time: None,
             previous_pause_gesture: false,
             pause_locked_until: 0.0,
@@ -150,7 +149,6 @@ impl BreakoutGame {
             status_chip(ui, "分数", self.score.to_string(), ACCENT_GREEN);
             status_chip(ui, "连击", self.combo.to_string(), ACCENT_ORANGE);
             status_chip(ui, "生命", self.lives.to_string(), ACCENT_RED);
-            status_chip(ui, "关卡", self.level.to_string(), ACCENT_BLUE);
         });
 
         ui.add_space(7.0);
@@ -191,12 +189,11 @@ impl BreakoutGame {
         self.score = 0;
         self.combo = 0;
         self.lives = 3;
-        self.level = 1;
         self.rebuild_bricks();
     }
 
     fn start(&mut self) {
-        if self.phase == BreakoutPhase::Over {
+        if self.phase == BreakoutPhase::Over || self.phase == BreakoutPhase::Won {
             self.reset();
         }
         if self.phase != BreakoutPhase::Running {
@@ -219,7 +216,10 @@ impl BreakoutGame {
         let threshold = pressure_pause_threshold();
         let active = top_force >= threshold;
         if active && !self.previous_pause_gesture && now >= self.pause_locked_until {
-            if self.phase == BreakoutPhase::Idle || self.phase == BreakoutPhase::Over {
+            if matches!(
+                self.phase,
+                BreakoutPhase::Idle | BreakoutPhase::Over | BreakoutPhase::Won
+            ) {
                 self.start();
             } else {
                 self.toggle_pause();
@@ -249,11 +249,7 @@ impl BreakoutGame {
     }
 
     fn launch_ball(&mut self) {
-        let direction = if self.level.is_multiple_of(2) {
+        let direction = 0.24;
-            -0.24
-        } else {
-            0.24
-        };
         self.ball_pos = egui::pos2(self.paddle_x, PADDLE_Y - PADDLE_H - BALL_RADIUS);
         self.ball_vel = egui::vec2(direction, -1.0).normalized() * BALL_SPEED;
     }
@@ -328,9 +324,8 @@ impl BreakoutGame {
         }
 
         if self.bricks.iter().all(|brick| !brick.alive) {
-            self.level += 1;
+            self.phase = BreakoutPhase::Won;
-            self.rebuild_bricks();
+            self.ball_vel = egui::Vec2::ZERO;
-            self.launch_ball();
         }
     }
 
@@ -362,6 +357,7 @@ impl BreakoutGame {
             BreakoutPhase::Idle => "待机",
             BreakoutPhase::Running => "运行",
             BreakoutPhase::Paused => "暂停",
+            BreakoutPhase::Won => "过关",
             BreakoutPhase::Over => "结束",
         }
     }
@@ -376,7 +372,7 @@ impl BreakoutGame {
         painter.rect_stroke(
             rect,
             egui::CornerRadius::same(6),
-            egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.accent, 110)),
+            egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 110)),
             egui::StrokeKind::Outside,
         );
 
@@ -391,6 +387,7 @@ impl BreakoutGame {
 
         if self.phase == BreakoutPhase::Idle
             || self.phase == BreakoutPhase::Paused
+            || self.phase == BreakoutPhase::Won
             || self.phase == BreakoutPhase::Over
         {
             paint_center_overlay(&painter, rect, self.phase);
@@ -407,6 +404,10 @@ pub fn control_from_matrix(raw: &[u32], rows: u32, cols: u32) -> BreakoutControl
     let cols = cols.max(1) as usize;
     let sample_rows = rows.min(2);
     let sample_cols = cols.min(2);
+    let top_gesture_rows = rows.min(1);
+    let top_gesture_cols = (cols / 3).clamp(1, cols);
+    let top_gesture_col_start = (cols - top_gesture_cols) / 2;
+    let top_gesture_col_end = top_gesture_col_start + top_gesture_cols;
     let avg = |row_start: usize, row_end: usize, col_start: usize, col_end: usize| -> f32 {
         let mut sum = 0.0;
         let mut count = 0.0;
@@ -434,7 +435,12 @@ pub fn control_from_matrix(raw: &[u32], rows: u32, cols: u32) -> BreakoutControl
 
     let left_force = tl + bl;
     let right_force = tr + br;
-    let top_force = tl + tr;
+    let top_force = avg(
+        0,
+        top_gesture_rows,
+        top_gesture_col_start,
+        top_gesture_col_end,
+    );
     let span = 1200.0_f32.max((PRESSURE_RANGE_MAX - PRESSURE_RANGE_MIN) * 0.22);
     let raw_axis = ((right_force - left_force) / span).clamp(-1.0, 1.0);
     let axis = if raw_axis.abs() < 0.045 {
@@ -473,7 +479,7 @@ fn circle_hits_rect(center: egui::Pos2, radius: f32, rect: egui::Rect) -> bool {
 fn status_chip(ui: &mut egui::Ui, label: &'static str, value: impl ToString, color: egui::Color32) {
     egui::Frame::new()
         .fill(color_alpha(ONE_DARK_PRO.panel_deep, 190))
-        .stroke(egui::Stroke::new(1.0_f32, color_alpha(color, 92)))
+        .stroke(egui::Stroke::new(1.0, color_alpha(color, 92)))
         .corner_radius(egui::CornerRadius::same(4))
         .inner_margin(egui::Margin::symmetric(8, 4))
         .show(ui, |ui| {
@@ -489,6 +495,7 @@ fn status_color(phase: BreakoutPhase) -> egui::Color32 {
         BreakoutPhase::Idle => ONE_DARK_PRO.text_dim,
         BreakoutPhase::Running => ACCENT_GREEN,
         BreakoutPhase::Paused => ACCENT_ORANGE,
+        BreakoutPhase::Won => ACCENT_GREEN,
         BreakoutPhase::Over => ACCENT_RED,
     }
 }
@@ -518,7 +525,7 @@ fn paint_arena_grid(painter: &egui::Painter, rect: egui::Rect) {
     painter.rect_stroke(
         rect,
         egui::CornerRadius::same(6),
-        egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.accent, 70)),
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 70)),
         egui::StrokeKind::Inside,
     );
 }
@@ -535,7 +542,7 @@ fn paint_brick(painter: &egui::Painter, arena: egui::Rect, brick: &Brick, index:
         painter.rect_stroke(
             rect.expand(4.0 * brick.flash),
             egui::CornerRadius::same(4),
-            egui::Stroke::new(1.4_f32, color_alpha(ONE_DARK_PRO.accent_hot, alpha)),
+            egui::Stroke::new(1.4, color_alpha(ONE_DARK_PRO.accent_hot, alpha)),
             egui::StrokeKind::Outside,
         );
     }
@@ -568,7 +575,7 @@ fn paint_control_meter(painter: &egui::Painter, arena: egui::Rect, control: Brea
     painter.rect_stroke(
         meter,
         egui::CornerRadius::same(4),
-        egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.border, 120)),
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border, 120)),
         egui::StrokeKind::Outside,
     );
     let center_x = meter.center().x;
@@ -577,7 +584,7 @@ fn paint_control_meter(painter: &egui::Painter, arena: egui::Rect, control: Brea
             egui::pos2(center_x, meter.top()),
             egui::pos2(center_x, meter.bottom()),
         ],
-        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
     );
     let marker_x = center_x + control.axis.clamp(-1.0, 1.0) * meter.width() * 0.45;
     painter.circle_filled(
@@ -611,6 +618,7 @@ fn paint_center_overlay(painter: &egui::Painter, rect: egui::Rect, phase: Breako
     let (title, detail) = match phase {
         BreakoutPhase::Idle => ("按压顶部或点击开始", "左右分区压力控制挡板"),
         BreakoutPhase::Paused => ("已暂停", "再次按压顶部、P 或点击暂停继续"),
+        BreakoutPhase::Won => ("恭喜过关", "按压顶部、点击或空格重新开始"),
         BreakoutPhase::Over => ("游戏结束", "点击或空格重开"),
         BreakoutPhase::Running => ("", ""),
     };

src/connection.rs

@@ -179,7 +179,6 @@ impl Default for ConnectionManager {
 }
 
 /// The blocking device loop that runs on a background thread.
-#[allow(clippy::too_many_arguments)]
 fn run_device_loop(
     port_name: &str,
     rows: u32,

src/matrix.rs

@@ -1,31 +1,5 @@
 pub const MATRIX_ROWS: u32 = 12;
 pub const MATRIX_COLS: u32 = 7;
-pub const UNFOLDED_L_CHANNEL_COUNT: usize = 8;
-pub const UNFOLDED_H_CHANNEL_COUNT: usize = 13;
-pub const UNFOLDED_SENSOR_COUNT: usize = UNFOLDED_L_CHANNEL_COUNT * UNFOLDED_H_CHANNEL_COUNT;
-pub const UNFOLDED_SENSOR_SEGMENT_COUNTS: [usize; 10] = [8, 3, 5, 8, 10, 44, 3, 5, 8, 10];
-
-pub const fn unfolded_lh_sample_index(l: usize, h: usize) -> usize {
-    debug_assert!(l < UNFOLDED_L_CHANNEL_COUNT);
-    debug_assert!(h < UNFOLDED_H_CHANNEL_COUNT);
-    h * UNFOLDED_L_CHANNEL_COUNT + l
-}
-
-#[cfg(test)]
-mod adc_scan_tests {
-    use super::*;
-
-    #[test]
-    fn scan_changes_l_before_advancing_h() {
-        let first_h0_scan = (0..UNFOLDED_L_CHANNEL_COUNT)
-            .map(|l| unfolded_lh_sample_index(l, 0))
-            .collect::<Vec<_>>();
-
-        assert_eq!(first_h0_scan, (0..8).collect::<Vec<_>>());
-        assert_eq!(unfolded_lh_sample_index(0, 1), 8);
-        assert_eq!(unfolded_lh_sample_index(7, 12), 103);
-    }
-}
 
 const BASE_MATRIX_SPAN: f32 = 24.0;
 const MATRIX_SPAN_GROWTH: f32 = 0.6;

src/recording.rs

@@ -145,11 +145,11 @@ impl Recorder {
             r.state == RecordingState::Recording || r.state == RecordingState::Paused,
             "nothing to stop"
         );
-        if r.state == RecordingState::Paused
+        if r.state == RecordingState::Paused {
-            && let Some(ps) = r.pause_start.take()
+            if let Some(ps) = r.pause_start.take() {
-        {
                 r.paused_duration_ms += ps.elapsed().as_millis() as u64;
             }
+        }
         r.state = RecordingState::Idle;
         Ok(())
     }
@@ -317,15 +317,16 @@ impl Recorder {
         }
 
         // Set the start instant so duration_ms() reports the imported span
-        if !r.frames.is_empty()
+        if !r.frames.is_empty() {
-            && let Some(last) = r.frames.last()
+            if let Some(last) = r.frames.last() {
-        {
                 // Pretend the recording happened `last.timestamp_ms` ago
                 // so that elapsed_ms() would return that value.
                 // We store a "fake" start by noting the offset.
-            r.start = Some(Instant::now() - std::time::Duration::from_millis(last.timestamp_ms));
+                r.start =
+                    Some(Instant::now() - std::time::Duration::from_millis(last.timestamp_ms));
                 r.paused_duration_ms = 0;
             }
+        }
 
         Ok(())
     }

src/render.rs

@@ -1,8 +1,5 @@
 use crate::{
-    matrix::{
+    matrix::{MatrixLayout, build_view_projection, glyph_world_position},
-        MatrixLayout, UNFOLDED_SENSOR_COUNT, build_view_projection, glyph_world_position,
-        unfolded_lh_sample_index,
-    },
     model::{AlphaMode, InstanceRaw, ModelVertex, Vertex},
     resources, texture,
 };
@@ -73,96 +70,26 @@ const HAND_TIP_MATRICES: [HandTipMatrix; 5] = [
     },
 ];
 
-const UNFOLDED_CANVAS_SIZE: [f32; 2] = [850.0, 750.0];
+const HAND_PALM_CHIPS: [HandPalmChip; 2] = [
-const UNFOLDED_CELL_SPACING_PX: f32 = 42.0;
-const UNFOLDED_SENSOR_CHIPS: [HandPalmChip; 10] = [
-    // Top cap: 2 rows x 4 columns.
     HandPalmChip {
-        center_px: [425.0, 165.0],
+        center_px: [538.0, 608.0],
-        size_px: [176.0, 88.0],
+        size_px: [248.0, 82.0],
-        angle_rad: 0.0,
+        angle_rad: 0.06,
-        rows: 2,
-        cols: 4,
-        sample_offset: 0,
-    },
-    // Left wing, authored from the outside towards the 11x4 center block.
-    HandPalmChip {
-        center_px: [140.0, 578.0],
-        size_px: [46.0, 132.0],
-        angle_rad: 0.0,
-        rows: 3,
-        cols: 1,
-        sample_offset: 8,
-    },
-    HandPalmChip {
-        center_px: [188.0, 534.0],
-        size_px: [46.0, 220.0],
-        angle_rad: 0.0,
         rows: 5,
-        cols: 1,
+        cols: 14,
-        sample_offset: 11,
     },
     HandPalmChip {
-        center_px: [236.0, 468.0],
+        center_px: [606.0, 780.0],
-        size_px: [46.0, 352.0],
+        size_px: [72.0, 214.0],
-        angle_rad: 0.0,
+        angle_rad: 0.05,
-        rows: 8,
-        cols: 1,
-        sample_offset: 16,
-    },
-    HandPalmChip {
-        center_px: [284.0, 424.0],
-        size_px: [46.0, 440.0],
-        angle_rad: 0.0,
-        rows: 10,
-        cols: 1,
-        sample_offset: 24,
-    },
-    // Center spine: 11 rows x 4 columns.
-    HandPalmChip {
-        center_px: [425.0, 444.0],
-        size_px: [176.0, 484.0],
-        angle_rad: 0.0,
         rows: 11,
         cols: 4,
-        sample_offset: 34,
-    },
-    // Right wing mirrors the left wing. Data remains ordered 3, 5, 8, 10.
-    HandPalmChip {
-        center_px: [710.0, 578.0],
-        size_px: [46.0, 132.0],
-        angle_rad: 0.0,
-        rows: 3,
-        cols: 1,
-        sample_offset: 78,
-    },
-    HandPalmChip {
-        center_px: [662.0, 534.0],
-        size_px: [46.0, 220.0],
-        angle_rad: 0.0,
-        rows: 5,
-        cols: 1,
-        sample_offset: 81,
-    },
-    HandPalmChip {
-        center_px: [614.0, 468.0],
-        size_px: [46.0, 352.0],
-        angle_rad: 0.0,
-        rows: 8,
-        cols: 1,
-        sample_offset: 86,
-    },
-    HandPalmChip {
-        center_px: [566.0, 424.0],
-        size_px: [46.0, 440.0],
-        angle_rad: 0.0,
-        rows: 10,
-        cols: 1,
-        sample_offset: 94,
     },
 ];
 
 const HAND_FINGER_SENSOR_CELLS: usize = 12 * 7;
+const HAND_PALM_HORIZONTAL_OFFSET: usize = HAND_FINGER_SENSOR_CELLS * 5;
+const HAND_PALM_VERTICAL_OFFSET: usize = HAND_PALM_HORIZONTAL_OFFSET + 5 * 14;
 
 // Each entry pins one miniature matrix to a fingertip in hand.png.
 // Coordinates are authored in source-image pixels so they are easy to tune by eye.
@@ -173,15 +100,14 @@ struct HandTipMatrix {
     angle_rad: f32,
 }
 
-// One block in the flat 270-degree sensor layout. Coordinates use a dedicated
+// Palm chips follow the hand layout: one horizontal 5x14 matrix and one vertical
-// 850x750 canvas so the unfolded shape stays prominent across window sizes.
+// 11x4 matrix, rendered as dark inset chip tiles on the palm.
 struct HandPalmChip {
     center_px: [f32; 2],
     size_px: [f32; 2],
     angle_rad: f32,
     rows: u32,
     cols: u32,
-    sample_offset: usize,
 }
 
 impl egui_wgpu::CallbackTrait for WgpuBackgroundCallback {
@@ -230,6 +156,7 @@ pub struct BackgroundRenderResources {
     dot_pipeline: wgpu::RenderPipeline,
     hand_membrane_pipeline: wgpu::RenderPipeline,
     hand_dot_pipeline: wgpu::RenderPipeline,
+    hand_palm_chip_pipeline: wgpu::RenderPipeline,
     hand_palm_dot_pipeline: wgpu::RenderPipeline,
     hand_image_bind_group: wgpu::BindGroup,
     hand_image_texture: texture::Texture,
@@ -241,6 +168,8 @@ pub struct BackgroundRenderResources {
     hand_membrane_instances: Vec<GlyphInstance>,
     hand_dot_instance_buffer: wgpu::Buffer,
     hand_dot_instances: Vec<GlyphInstance>,
+    hand_palm_chip_instance_buffer: wgpu::Buffer,
+    hand_palm_chip_instances: Vec<GlyphInstance>,
     hand_palm_dot_instance_buffer: wgpu::Buffer,
     hand_palm_dot_instances: Vec<GlyphInstance>,
     render_options: RenderOptions,
@@ -348,7 +277,10 @@ impl BackgroundRenderResources {
             build_view_projection(1.0, &layout),
             surface_is_srgb,
             render_options,
-            UNFOLDED_CANVAS_SIZE,
+            [
+                hand_image_texture.width as f32,
+                hand_image_texture.height as f32,
+            ],
         );
         let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             label: Some("Pressure Matrix Uniform Buffer"),
@@ -565,6 +497,8 @@ impl BackgroundRenderResources {
             create_hand_membrane_pipeline(device, target_format, &shader, &pipeline_layout);
         let hand_dot_pipeline =
             create_hand_dot_pipeline(device, target_format, &shader, &pipeline_layout);
+        let hand_palm_chip_pipeline =
+            create_hand_palm_chip_pipeline(device, target_format, &shader, &pipeline_layout);
         let hand_palm_dot_pipeline =
             create_hand_palm_dot_pipeline(device, target_format, &shader, &pipeline_layout);
 
@@ -617,8 +551,23 @@ impl BackgroundRenderResources {
                 contents: bytemuck::cast_slice(&hand_dot_instances),
                 usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             });
-        let hand_palm_dot_instances =
+        let hand_palm_chip_instances = build_hand_palm_chip_instances(
-            build_hand_palm_dot_instances(rows, cols, &[[0.0, 0.0]; PRESSURE_CELL_COUNT]);
+            hand_image_texture.width as f32,
+            hand_image_texture.height as f32,
+        );
+        let hand_palm_chip_instance_buffer =
+            device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Hand Palm Chip Instance Buffer"),
+                contents: bytemuck::cast_slice(&hand_palm_chip_instances),
+                usage: wgpu::BufferUsages::VERTEX,
+            });
+        let hand_palm_dot_instances = build_hand_palm_dot_instances(
+            rows,
+            cols,
+            hand_image_texture.width as f32,
+            hand_image_texture.height as f32,
+            &[[0.0, 0.0]; PRESSURE_CELL_COUNT],
+        );
         let hand_palm_dot_instance_buffer =
             device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                 label: Some("Hand Palm Chip Dot Instance Buffer"),
@@ -640,6 +589,7 @@ impl BackgroundRenderResources {
             dot_pipeline,
             hand_membrane_pipeline,
             hand_dot_pipeline,
+            hand_palm_chip_pipeline,
             hand_palm_dot_pipeline,
             hand_image_bind_group,
             hand_image_texture,
@@ -650,6 +600,8 @@ impl BackgroundRenderResources {
             hand_membrane_instances,
             hand_dot_instance_buffer,
             hand_dot_instances,
+            hand_palm_chip_instance_buffer,
+            hand_palm_chip_instances,
             hand_palm_dot_instance_buffer,
             hand_palm_dot_instances,
             render_options,
@@ -671,7 +623,10 @@ impl BackgroundRenderResources {
             build_view_projection(aspect, &self.layout),
             self.surface_is_srgb,
             self.render_options,
-            UNFOLDED_CANVAS_SIZE,
+            [
+                self.hand_image_texture.width as f32,
+                self.hand_image_texture.height as f32,
+            ],
         );
         queue.write_buffer(
             &self.uniform_buffer,
@@ -698,8 +653,8 @@ impl BackgroundRenderResources {
             hand_pressure
         };
 
-        // Keep legacy fingertip buffers current while both hardware modes share
+        // Hand mode uses UV-anchored fingertip matrices over hand.png.
-        // the same renderer resources.
+        // Rebuild their instance positions here so pressure colors update every frame.
         self.hand_dot_instances = build_hand_dot_instances(
             self.rows,
             self.cols,
@@ -713,9 +668,15 @@ impl BackgroundRenderResources {
             bytemuck::cast_slice(&self.hand_dot_instances),
         );
 
-        // Rebuild the 104-cell unfolded layout with the latest gateway samples.
+        // Palm chips reuse the same live 12x7 pressure frame, but draw it as
-        self.hand_palm_dot_instances =
+        // embedded micro-pixels inside dark chip tiles.
-            build_hand_palm_dot_instances(self.rows, self.cols, hand_pressure);
+        self.hand_palm_dot_instances = build_hand_palm_dot_instances(
+            self.rows,
+            self.cols,
+            self.hand_image_texture.width as f32,
+            self.hand_image_texture.height as f32,
+            hand_pressure,
+        );
         queue.write_buffer(
             &self.hand_palm_dot_instance_buffer,
             0,
@@ -731,7 +692,12 @@ impl BackgroundRenderResources {
 
         match active_mode {
             ActiveMode::Finger(mode) => self.paint_finger(render_pass, mode),
-            ActiveMode::Hand(mode) => self.paint_hand(render_pass, mode),
+            ActiveMode::Hand(mode) => {
+                render_pass.set_pipeline(&self.hand_image_pipeline);
+                render_pass.set_bind_group(1, &self.hand_image_bind_group, &[]);
+                render_pass.draw(0..6, 0..1);
+                self.paint_hand(render_pass, mode);
+            }
         }
     }
 
@@ -753,7 +719,22 @@ impl BackgroundRenderResources {
     fn paint_hand(&self, render_pass: &mut wgpu::RenderPass<'_>, mode: &HandGatewayMode) {
         let _range = mode.range.clone();
 
-        // Match Finger mode: draw only the 104 independent pressure dots.
+        // First draw the translucent sensor membranes, then draw live pressure beads on their grid.
+        render_pass.set_pipeline(&self.hand_membrane_pipeline);
+        render_pass.set_vertex_buffer(0, self.glyph_vertex_buffer.slice(..));
+        render_pass.set_vertex_buffer(1, self.hand_membrane_instance_buffer.slice(..));
+        render_pass.draw(0..6, 0..self.hand_membrane_instances.len() as u32);
+
+        render_pass.set_pipeline(&self.hand_dot_pipeline);
+        render_pass.set_vertex_buffer(0, self.glyph_vertex_buffer.slice(..));
+        render_pass.set_vertex_buffer(1, self.hand_dot_instance_buffer.slice(..));
+        render_pass.draw(0..6, 0..self.hand_dot_instances.len() as u32);
+
+        render_pass.set_pipeline(&self.hand_palm_chip_pipeline);
+        render_pass.set_vertex_buffer(0, self.glyph_vertex_buffer.slice(..));
+        render_pass.set_vertex_buffer(1, self.hand_palm_chip_instance_buffer.slice(..));
+        render_pass.draw(0..6, 0..self.hand_palm_chip_instances.len() as u32);
+
         render_pass.set_pipeline(&self.hand_palm_dot_pipeline);
         render_pass.set_vertex_buffer(0, self.glyph_vertex_buffer.slice(..));
         render_pass.set_vertex_buffer(1, self.hand_palm_dot_instance_buffer.slice(..));
@@ -1091,6 +1072,39 @@ fn create_hand_dot_pipeline(
     })
 }
 
+fn create_hand_palm_chip_pipeline(
+    device: &wgpu::Device,
+    target_format: &wgpu::TextureFormat,
+    shader: &wgpu::ShaderModule,
+    layout: &wgpu::PipelineLayout,
+) -> wgpu::RenderPipeline {
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Hand Palm Embedded Chip Pipeline"),
+        layout: Some(layout),
+        vertex: wgpu::VertexState {
+            module: shader,
+            entry_point: Some("vs_hand_palm_chip"),
+            compilation_options: Default::default(),
+            buffers: &[GlyphVertex::desc(), GlyphInstance::desc()],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: shader,
+            entry_point: Some("fs_hand_palm_chip"),
+            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 create_hand_palm_dot_pipeline(
     device: &wgpu::Device,
     target_format: &wgpu::TextureFormat,
@@ -1142,6 +1156,28 @@ fn build_hand_membrane_instances(image_width: f32, image_height: f32) -> Vec<Gly
         .collect()
 }
 
+fn build_hand_palm_chip_instances(image_width: f32, image_height: f32) -> Vec<GlyphInstance> {
+    HAND_PALM_CHIPS
+        .iter()
+        .map(|chip| {
+            let uv_x = chip.center_px[0] / image_width.max(1.0);
+            let uv_y = chip.center_px[1] / image_height.max(1.0);
+
+            GlyphInstance {
+                // Palm chip shaders read xy as hand.png UV.
+                world_position: [uv_x, uv_y, 0.0, 1.0],
+                // Store chip angle, source-image pixel size, and matrix shape for the shader grid.
+                style: [
+                    chip.angle_rad,
+                    chip.size_px[0],
+                    chip.size_px[1],
+                    (chip.rows * 100 + chip.cols) as f32,
+                ],
+            }
+        })
+        .collect()
+}
+
 fn build_hand_dot_instances(
     rows: u32,
     cols: u32,
@@ -1189,26 +1225,44 @@ fn build_hand_dot_instances(
 fn build_hand_palm_dot_instances(
     _rows: u32,
     _cols: u32,
+    image_width: f32,
+    image_height: f32,
     pressure: &[[f32; 2]],
 ) -> Vec<GlyphInstance> {
-    let chip_dot_count: usize = UNFOLDED_SENSOR_CHIPS
+    let chip_dot_count: usize = HAND_PALM_CHIPS
         .iter()
         .map(|chip| (chip.rows * chip.cols) as usize)
         .sum();
-    debug_assert_eq!(chip_dot_count, UNFOLDED_SENSOR_COUNT);
     let mut instances = Vec::with_capacity(chip_dot_count);
 
-    for (chip_index, chip) in UNFOLDED_SENSOR_CHIPS.iter().enumerate() {
+    for (chip_index, chip) in HAND_PALM_CHIPS.into_iter().enumerate() {
+        let cos = chip.angle_rad.cos();
+        let sin = chip.angle_rad.sin();
+        // Leave a bevel around the chip so the matrix reads as embedded pixels.
+        let active_size = [chip.size_px[0] * 0.72, chip.size_px[1] * 0.76];
+
         for row in 0..chip.rows {
             for col in 0..chip.cols {
-                let index = unfolded_adc_sample_index(chip_index, row, col);
+                let index = (row * chip.cols + col) as usize;
-                let [normalized, display_value] = sample_pressure_at(pressure, index, index);
+                let offset = match chip_index {
-                let [x, y] = unfolded_cell_position(&chip, row, col);
+                    0 => HAND_PALM_HORIZONTAL_OFFSET,
+                    _ => HAND_PALM_VERTICAL_OFFSET,
+                };
+                let [normalized, display_value] =
+                    sample_pressure_at(pressure, offset + index, index);
+
+                let local_x =
+                    (col as f32 - chip.cols as f32 / 2.0 + 0.5) / chip.cols as f32 * active_size[0];
+                let local_y =
+                    (row as f32 - chip.rows as f32 / 2.0 + 0.5) / chip.rows as f32 * active_size[1];
+
+                let x = chip.center_px[0] + local_x * cos - local_y * sin;
+                let y = chip.center_px[1] + local_x * sin + local_y * cos;
 
                 instances.push(GlyphInstance {
                     world_position: [
-                        x / UNFOLDED_CANVAS_SIZE[0],
+                        x / image_width.max(1.0),
-                        y / UNFOLDED_CANVAS_SIZE[1],
+                        y / image_height.max(1.0),
                         0.0,
                         1.0,
                     ],
@@ -1221,47 +1275,6 @@ fn build_hand_palm_dot_instances(
     instances
 }
 
-fn unfolded_adc_sample_index(chip_index: usize, row: u32, col: u32) -> usize {
-    // Raw sample 0 is L0H0. The scan advances L first:
-    // L0H0, L1H0, …, L7H0, L0H1, …, L7H12.
-    // The PCB unfolds those channel pairs into the ten visual regions below.
-    let (l, h) = match chip_index {
-        0 => (5 - col, 12 - row),         // top cap: L5…L2 × H12…H11
-        1 => (6, row),                    // left outer tip: L6 × H0…H2
-        2 => (7, folded_five_row_h(row)), // left folded wing
-        3 => (7, 10 - row),               // left inner wing: L7 × H10…H3
-        4 => (6, 12 - row),               // left inner spine: L6 × H12…H3
-        5 => (5 - col, 10 - row),         // center: L5…L2 × H10…H0
-        6 => (1, row),                    // right outer tip: L1 × H0…H2
-        7 => (0, folded_five_row_h(row)), // right folded wing
-        8 => (0, 10 - row),               // right inner wing: L0 × H10…H3
-        9 => (1, 12 - row),               // right inner spine: L1 × H12…H3
-        _ => unreachable!("invalid unfolded PCB region"),
-    };
-
-    unfolded_lh_sample_index(l as usize, h as usize)
-}
-
-fn folded_five_row_h(row: u32) -> u32 {
-    const PCB_H_ROUTE: [u32; 5] = [12, 11, 0, 1, 2];
-    PCB_H_ROUTE[row as usize]
-}
-fn unfolded_cell_position(chip: &HandPalmChip, row: u32, col: u32) -> [f32; 2] {
-    let cos = chip.angle_rad.cos();
-    let sin = chip.angle_rad.sin();
-    // Author every region on the same point grid. Using the last row as the
-    // vertical anchor keeps the stepped wing columns exactly bottom-aligned.
-    let bottom_center_y = chip.center_px[1] + chip.size_px[1] * 0.5 - 22.0;
-    let local_x = (col as f32 - chip.cols as f32 / 2.0 + 0.5) * UNFOLDED_CELL_SPACING_PX;
-    let y_from_bottom = (chip.rows.saturating_sub(row + 1)) as f32 * UNFOLDED_CELL_SPACING_PX;
-    let local_y = -y_from_bottom;
-
-    [
-        chip.center_px[0] + local_x * cos - local_y * sin,
-        bottom_center_y + local_x * sin + local_y * cos,
-    ]
-}
-
 fn sample_pressure_at(pressure: &[[f32; 2]], index: usize, fallback_index: usize) -> [f32; 2] {
     pressure
         .get(index)
@@ -1270,225 +1283,6 @@ fn sample_pressure_at(pressure: &[[f32; 2]], index: usize, fallback_index: usize
         .unwrap_or([0.0, 0.0])
 }
 
-#[cfg(test)]
-mod unfolded_layout_tests {
-    use super::*;
-    use crate::matrix::UNFOLDED_SENSOR_SEGMENT_COUNTS;
-
-    #[test]
-    fn unfolded_layout_maps_every_lh_adc_channel_once() {
-        let mut seen = [false; UNFOLDED_SENSOR_COUNT];
-
-        for (chip_index, chip) in UNFOLDED_SENSOR_CHIPS.iter().enumerate() {
-            for row in 0..chip.rows {
-                for col in 0..chip.cols {
-                    let index = unfolded_adc_sample_index(chip_index, row, col);
-                    assert!(index < UNFOLDED_SENSOR_COUNT);
-                    assert!(!seen[index], "duplicate ADC sample index {index}");
-                    seen[index] = true;
-                }
-            }
-        }
-
-        assert!(seen.into_iter().all(|mapped| mapped));
-        assert_eq!(unfolded_lh_sample_index(0, 0), 0); // first raw sample
-        assert_eq!(unfolded_lh_sample_index(1, 0), 1); // L changes first
-        assert_eq!(unfolded_lh_sample_index(7, 0), 7);
-        assert_eq!(unfolded_lh_sample_index(0, 1), 8); // then H advances
-        assert_eq!(unfolded_adc_sample_index(7, 0, 0), 96); // L0H12
-        assert_eq!(unfolded_adc_sample_index(6, 0, 0), 1); // L1H0
-        assert_eq!(unfolded_lh_sample_index(7, 12), 103); // last rendered sample
-    }
-
-    #[test]
-    fn unfolded_layout_matches_annotated_adc_intersections() {
-        // Right folded/outer intersections: 1=L0H0, 2=L1H0,
-        // 9=L0H1, 10=L1H1, 17=L0H2, 18=L1H2.
-        assert_eq!(unfolded_adc_sample_index(7, 2, 0) + 1, 1);
-        assert_eq!(unfolded_adc_sample_index(6, 0, 0) + 1, 2);
-        assert_eq!(unfolded_adc_sample_index(7, 3, 0) + 1, 9);
-        assert_eq!(unfolded_adc_sample_index(6, 1, 0) + 1, 10);
-        assert_eq!(unfolded_adc_sample_index(7, 4, 0) + 1, 17);
-        assert_eq!(unfolded_adc_sample_index(6, 2, 0) + 1, 18);
-
-        // Right inner routes continue upward from H3.
-        assert_eq!(
-            (0..8)
-                .map(|row| unfolded_adc_sample_index(8, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![81, 73, 65, 57, 49, 41, 33, 25]
-        );
-        assert_eq!(
-            (0..10)
-                .map(|row| unfolded_adc_sample_index(9, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![98, 90, 82, 74, 66, 58, 50, 42, 34, 26]
-        );
-
-        // Left routes mirror the right side's PCB continuation.
-        assert_eq!(
-            (0..3)
-                .map(|row| unfolded_adc_sample_index(1, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![7, 15, 23]
-        );
-        assert_eq!(
-            (0..5)
-                .map(|row| unfolded_adc_sample_index(2, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![104, 96, 8, 16, 24]
-        );
-        assert_eq!(
-            (0..8)
-                .map(|row| unfolded_adc_sample_index(3, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![88, 80, 72, 64, 56, 48, 40, 32]
-        );
-        assert_eq!(
-            (0..10)
-                .map(|row| unfolded_adc_sample_index(4, row, 0) + 1)
-                .collect::<Vec<_>>(),
-            vec![103, 95, 87, 79, 71, 63, 55, 47, 39, 31]
-        );
-
-        // Center rows H0…H7, each ordered L5, L4, L3, L2.
-        for h in 0..=7 {
-            let row = 10 - h;
-            let expected = (2..=5)
-                .rev()
-                .map(|l| unfolded_lh_sample_index(l, h as usize) + 1)
-                .collect::<Vec<_>>();
-            let rendered = (0..4)
-                .map(|col| unfolded_adc_sample_index(5, row, col) + 1)
-                .collect::<Vec<_>>();
-            assert_eq!(rendered, expected);
-        }
-    }
-
-    #[test]
-    fn annotated_folded_points_share_the_same_physical_rows() {
-        let same_y = |left_chip: usize, left_row: u32, right_chip: usize, right_row: u32| {
-            let left = unfolded_cell_position(&UNFOLDED_SENSOR_CHIPS[left_chip], left_row, 0)[1];
-            let right = unfolded_cell_position(&UNFOLDED_SENSOR_CHIPS[right_chip], right_row, 0)[1];
-            assert!((left - right).abs() < 0.01);
-        };
-
-        // Left outer pairs: 7/8, 15/16, 23/24.
-        for row in 0..3 {
-            same_y(1, row, 2, row + 2);
-        }
-
-        // Right outer pairs: 2/1, 10/9, 18/17.
-        for row in 0..3 {
-            same_y(6, row, 7, row + 2);
-        }
-
-        // Inner continuations align by H despite belonging to different strips.
-        for row in 0..8 {
-            same_y(3, row, 4, row + 2);
-            same_y(8, row, 9, row + 2);
-        }
-    }
-
-    #[test]
-    fn unfolded_layout_matches_requested_shapes() {
-        let shapes = UNFOLDED_SENSOR_CHIPS.map(|chip| (chip.rows, chip.cols));
-        let sample_counts = UNFOLDED_SENSOR_CHIPS.map(|chip| (chip.rows * chip.cols) as usize);
-
-        assert_eq!(
-            shapes,
-            [
-                (2, 4),
-                (3, 1),
-                (5, 1),
-                (8, 1),
-                (10, 1),
-                (11, 4),
-                (3, 1),
-                (5, 1),
-                (8, 1),
-                (10, 1),
-            ]
-        );
-        assert_eq!(sample_counts, UNFOLDED_SENSOR_SEGMENT_COUNTS);
-    }
-
-    #[test]
-    fn unfolded_wings_are_mirrored_around_center() {
-        let center_x = UNFOLDED_SENSOR_CHIPS[5].center_px[0];
-
-        for (left, right) in UNFOLDED_SENSOR_CHIPS[1..5]
-            .iter()
-            .zip(UNFOLDED_SENSOR_CHIPS[6..10].iter())
-        {
-            assert_eq!((left.rows, left.cols), (right.rows, right.cols));
-            assert_eq!(left.center_px[1], right.center_px[1]);
-            assert!(
-                ((center_x - left.center_px[0]) - (right.center_px[0] - center_x)).abs() < 0.01
-            );
-        }
-    }
-
-    #[test]
-    fn unfolded_layout_fits_its_canvas() {
-        for chip in UNFOLDED_SENSOR_CHIPS {
-            let half_width = chip.size_px[0] * 0.5;
-            let half_height = chip.size_px[1] * 0.5;
-
-            assert!(chip.center_px[0] - half_width >= 0.0);
-            assert!(chip.center_px[0] + half_width <= UNFOLDED_CANVAS_SIZE[0]);
-            assert!(chip.center_px[1] - half_height >= 0.0);
-            assert!(chip.center_px[1] + half_height <= UNFOLDED_CANVAS_SIZE[1]);
-        }
-    }
-
-    #[test]
-    fn unfolded_wing_rows_share_one_bottom_baseline() {
-        let wing_indices = [1usize, 2, 3, 4, 6, 7, 8, 9];
-        let expected_y = unfolded_cell_position(
-            &UNFOLDED_SENSOR_CHIPS[wing_indices[0]],
-            UNFOLDED_SENSOR_CHIPS[wing_indices[0]].rows - 1,
-            0,
-        )[1];
-
-        for index in wing_indices {
-            let chip = &UNFOLDED_SENSOR_CHIPS[index];
-            let bottom_y = unfolded_cell_position(chip, chip.rows - 1, 0)[1];
-            assert!((bottom_y - expected_y).abs() < 0.01);
-        }
-    }
-
-    #[test]
-    fn unfolded_wings_are_compact_with_more_space_at_center() {
-        let left_x = UNFOLDED_SENSOR_CHIPS[1..5]
-            .iter()
-            .map(|chip| chip.center_px[0])
-            .collect::<Vec<_>>();
-        let wing_gap = left_x[1] - left_x[0];
-        assert!((wing_gap - 48.0).abs() < 0.01);
-        assert!(
-            left_x
-                .windows(2)
-                .all(|pair| (pair[1] - pair[0] - wing_gap).abs() < 0.01)
-        );
-
-        let center_left_x = unfolded_cell_position(&UNFOLDED_SENSOR_CHIPS[5], 0, 0)[0];
-        let left_inner_x = unfolded_cell_position(&UNFOLDED_SENSOR_CHIPS[4], 0, 0)[0];
-        assert!(center_left_x - left_inner_x > wing_gap);
-    }
-
-    #[test]
-    fn unfolded_top_block_sits_close_to_center_block() {
-        let top = &UNFOLDED_SENSOR_CHIPS[0];
-        let center = &UNFOLDED_SENSOR_CHIPS[5];
-        let top_bottom_y = unfolded_cell_position(top, top.rows - 1, 0)[1];
-        let center_top_y = unfolded_cell_position(center, 0, 0)[1];
-
-        assert!(center_top_y > top_bottom_y);
-        assert!(center_top_y - top_bottom_y < UNFOLDED_CELL_SPACING_PX * 2.0);
-    }
-}
-
 fn build_glyph_instances(
     rows: u32,
     cols: u32,

src/resources.rs

@@ -457,7 +457,6 @@ fn create_color_material(
     ))
 }
 
-#[allow(clippy::too_many_arguments)]
 fn create_material(
     device: &wgpu::Device,
     texture_bind_group_layout: &wgpu::BindGroupLayout,
@@ -703,7 +702,6 @@ fn append_gltf_node_meshes(
     Ok(())
 }
 
-#[allow(clippy::too_many_arguments)]
 fn append_gltf_primitive_mesh(
     mesh_name: &str,
     primitive_index: usize,
@@ -971,7 +969,7 @@ fn rgba_from_chunks(
     read_component: fn(&[u8]) -> u8,
 ) -> anyhow::Result<Vec<u8>> {
     let pixel_width = channels * component_width;
-    if pixel_width == 0 || !pixels.len().is_multiple_of(pixel_width) {
+    if pixel_width == 0 || pixels.len() % pixel_width != 0 {
         bail!("invalid glTF image byte length for {channels} channels");
     }
 

src/serial_core/codecs/hand_gateway.rs

@@ -146,7 +146,7 @@ impl HandGatewayCodec {
     }
 
     pub fn parse_node_payload(data: &[u8]) -> Result<Vec<u16>, CodecError> {
-        if !data.len().is_multiple_of(2) {
+        if data.len() % 2 != 0 {
             return Err(CodecError::InvalidLength);
         }
 

src/serial_core/codecs/tactile_a.rs

@@ -31,7 +31,7 @@ impl TactileACodec {
     }
 
     pub fn parse_data_frame(data: &[u8]) -> Result<Vec<i32>, CodecError> {
-        if !data.len().is_multiple_of(2) {
+        if data.len() % 2 != 0 {
             return Err(CodecError::InvalidLength);
         }
 
@@ -132,7 +132,7 @@ impl Codec<TactileAFrame> for TactileACodec {
             let need_check_data = self.buffer[0..14 + except_data_len].to_vec();
             let payload = self.buffer[14..14 + except_data_len].to_vec();
             let crc8_itu_alg = crc::Crc::<u8>::new(&crc::CRC_8_I_432_1);
-            let checksum = crc8_itu_alg.checksum(need_check_data.as_slice());
+            let checksum = crc8_itu_alg.checksum(&need_check_data.as_slice());
             if self.buffer[frame_length - 1] != checksum {
                 log::debug!(
                     "checksum mismatch: expected {:02X}, got {:02X}, frame_len={}",
@@ -188,61 +188,3 @@ impl Codec<TactileAFrame> for TactileACodec {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::serial_core::codec::Codec;
-    use std::time::Instant;
-
-    const FINGER_3D_ROWS: usize = 12;
-    const FINGER_3D_COLS: usize = 9;
-    const FINGER_3D_DATA_LEN: usize = FINGER_3D_ROWS * FINGER_3D_COLS * 2;
-
-    #[test]
-    fn finger_3d_request_asks_for_108_samples() {
-        let codec = TactileACodec::new(FINGER_3D_COLS, FINGER_3D_ROWS);
-        let frame = TactileACodec::build_req_frame(FINGER_3D_COLS, FINGER_3D_ROWS).unwrap();
-        let encoded = codec.encode(&frame).unwrap();
-
-        assert_eq!(
-            u16::from_le_bytes([encoded[11], encoded[12]]) as usize,
-            FINGER_3D_DATA_LEN
-        );
-    }
-
-    #[test]
-    fn finger_3d_decode_accepts_108_samples_across_reads() {
-        let mut codec = TactileACodec::new(FINGER_3D_COLS, FINGER_3D_ROWS);
-        let payload = (0..FINGER_3D_ROWS * FINGER_3D_COLS)
-            .flat_map(|value| (value as u16).to_le_bytes())
-            .collect::<Vec<_>>();
-        let mut response = Vec::new();
-        response.extend_from_slice(&[0xAA, 0x55]);
-        response.extend_from_slice(&9_u16.to_le_bytes());
-        response.extend_from_slice(&[0x34, 0x00, 0xFB]);
-        response.extend_from_slice(&7168_u32.to_le_bytes());
-        response.extend_from_slice(&(FINGER_3D_DATA_LEN as u16).to_le_bytes());
-        response.push(0);
-        response.extend_from_slice(&payload);
-        response.push(calc_crc8_itu(&response));
-
-        let split = response.len() / 2;
-        assert!(
-            codec
-                .decode(&response[..split], Instant::now())
-                .unwrap()
-                .is_empty()
-        );
-        let frames = codec.decode(&response[split..], Instant::now()).unwrap();
-
-        let TactileAFrame::Rep(rep) = &frames[0] else {
-            panic!("expected response frame");
-        };
-        assert_eq!(rep.payload.len(), FINGER_3D_DATA_LEN);
-        assert_eq!(
-            TactileACodec::parse_data_frame(&rep.payload).unwrap().len(),
-            108
-        );
-    }
-}

src/serial_core/multi_dim_force.rs

@@ -87,7 +87,7 @@ impl PztProcessor {
             return 0.0;
         }
 
-        if n.is_multiple_of(2) {
+        if n % 2 == 0 {
             (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0
         } else {
             sorted[n / 2]

src/serial_core/serial.rs

@@ -14,6 +14,7 @@ const DEFAULT_HAND_GATEWAY_NODE_SAMPLE_COUNTS: &[u16] = &[84, 84, 84, 84, 84, 70
 pub struct SerialIoStats {
     pub rx_bytes: u64,
     pub tx_bytes: u64,
+    pub rx_frames: u64,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -24,7 +25,6 @@ pub enum SerialProtocol {
 
 /// Runs the serial polling loop on the calling (background) thread.
 /// Sends decoded pressure matrix data (Vec<i32>) to the output channel.
-#[allow(clippy::too_many_arguments)]
 pub fn run_serial_loop(
     port: &mut dyn ReadWrite,
     rows: usize,
@@ -74,12 +74,12 @@ fn run_tactile_a_loop(
         }
 
         // Send poll request
-        if let Ok(req_bytes) = codec.encode(&req_frame)
+        if let Ok(req_bytes) = codec.encode(&req_frame) {
-            && port.write_all(&req_bytes).is_ok()
+            if port.write_all(&req_bytes).is_ok() {
-        {
                 io_stats.tx_bytes += req_bytes.len() as u64;
                 publish_stats(stats_tx, io_stats);
             }
+        }
 
         // Read response with poll interval
         let deadline = Instant::now() + poll_interval;
@@ -94,15 +94,17 @@ fn run_tactile_a_loop(
                     publish_stats(stats_tx, io_stats);
                     if let Ok(frames) = codec.decode(&buffer[..n], session_started_at) {
                         for frame in frames {
-                            if let TactileAFrame::Rep(rep) = frame
+                            if let TactileAFrame::Rep(rep) = frame {
-                                && let Ok(vals) = TactileACodec::parse_data_frame(&rep.payload)
+                                if let Ok(vals) = TactileACodec::parse_data_frame(&rep.payload) {
-                            {
                                     if let Some(recorder) = recorder {
                                         let pressures: Vec<u32> =
                                             vals.iter().map(|v| (*v).max(0) as u32).collect();
                                         recorder.add_frame(&pressures);
                                     }
                                     let _ = sample_tx.try_send(vals);
+                                    io_stats.rx_frames += 1;
+                                    publish_stats(stats_tx, io_stats);
+                                }
                             }
                         }
                     }
@@ -192,6 +194,8 @@ fn run_hand_gateway_loop(
                                     recorder.add_frame(&pressures);
                                 }
                                 let _ = sample_tx.try_send(vals);
+                                io_stats.rx_frames += 1;
+                                publish_stats(stats_tx, io_stats);
                             }
                         }
                     }

src/style.rs

@@ -62,6 +62,7 @@ pub const METRICS: DesignMetrics = DesignMetrics {
 pub mod layout {
     pub const TITLE_BAR_HEIGHT: f32 = 36.0;
     pub const CONFIG_BAR_HEIGHT: f32 = 48.0;
+    pub const WORKSPACE_TOP: f32 = TITLE_BAR_HEIGHT + CONFIG_BAR_HEIGHT;
     pub const CENTER_PANEL_TOP: f32 = 48.0;
     pub const LEFT_X: f32 = 24.0;
     pub const RIGHT_X: f32 = 1328.0;
@@ -77,7 +78,7 @@ pub fn apply_theme(ctx: &egui::Context, theme: &AppTheme) {
     visuals.override_text_color = Some(theme.text);
     visuals.panel_fill = theme.bg;
     visuals.window_fill = theme.panel;
-    visuals.window_stroke = egui::Stroke::new(1.0_f32, theme.border);
+    visuals.window_stroke = egui::Stroke::new(1.0, theme.border);
     visuals.extreme_bg_color = theme.panel_deep;
     visuals.faint_bg_color = theme.panel_strong;
     visuals.code_bg_color = theme.panel_deep;
@@ -85,23 +86,23 @@ pub fn apply_theme(ctx: &egui::Context, theme: &AppTheme) {
     visuals.error_fg_color = ACCENT_RED;
 
     visuals.widgets.noninteractive.bg_fill = theme.panel_strong;
-    visuals.widgets.noninteractive.bg_stroke = egui::Stroke::new(1.0_f32, theme.border_soft);
+    visuals.widgets.noninteractive.bg_stroke = egui::Stroke::new(1.0, theme.border_soft);
-    visuals.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
+    visuals.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0, theme.text);
     visuals.widgets.inactive.bg_fill = theme.panel_strong;
-    visuals.widgets.inactive.bg_stroke = egui::Stroke::new(1.0_f32, theme.border_soft);
+    visuals.widgets.inactive.bg_stroke = egui::Stroke::new(1.0, theme.border_soft);
-    visuals.widgets.inactive.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
+    visuals.widgets.inactive.fg_stroke = egui::Stroke::new(1.0, theme.text);
     visuals.widgets.hovered.bg_fill = egui::Color32::from_rgb(44, 57, 70);
-    visuals.widgets.hovered.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent);
+    visuals.widgets.hovered.bg_stroke = egui::Stroke::new(1.0, theme.accent);
-    visuals.widgets.hovered.fg_stroke = egui::Stroke::new(1.0_f32, egui::Color32::WHITE);
+    visuals.widgets.hovered.fg_stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
     visuals.widgets.active.bg_fill = theme.accent;
-    visuals.widgets.active.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent_hot);
+    visuals.widgets.active.bg_stroke = egui::Stroke::new(1.0, theme.accent_hot);
-    visuals.widgets.active.fg_stroke = egui::Stroke::new(1.0_f32, egui::Color32::WHITE);
+    visuals.widgets.active.fg_stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
     visuals.widgets.open.bg_fill = egui::Color32::from_rgb(39, 50, 62);
-    visuals.widgets.open.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent);
+    visuals.widgets.open.bg_stroke = egui::Stroke::new(1.0, theme.accent);
-    visuals.widgets.open.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
+    visuals.widgets.open.fg_stroke = egui::Stroke::new(1.0, theme.text);
 
     visuals.selection.bg_fill = egui::Color32::from_rgb(35, 123, 140);
-    visuals.selection.stroke = egui::Stroke::new(1.0_f32, egui::Color32::WHITE);
+    visuals.selection.stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
     visuals.hyperlink_color = theme.accent_hot;
     ctx.set_visuals(visuals);
 
@@ -127,8 +128,8 @@ pub fn apply_fonts(ctx: &egui::Context) {
     let mut fonts = egui::FontDefinitions::default();
 
     fonts.font_data.insert(
-        "MapleMono-NF-CN-Bold".to_owned(),
+        "Hack-Bold".to_owned(),
-        egui::FontData::from_static(include_bytes!("../static/MapleMono-NF-CN-Bold.ttf")).into(),
+        egui::FontData::from_static(include_bytes!("../static/Hack-Bold.ttf")).into(),
     );
 
     let has_yahei = std::fs::read(r"C:\Windows\Fonts\msyh.ttc")
@@ -145,7 +146,7 @@ pub fn apply_fonts(ctx: &egui::Context) {
         .families
         .entry(egui::FontFamily::Proportional)
         .or_default()
-        .insert(0, "MapleMono-NF-CN-Bold".to_owned());
+        .insert(0, "Hack-Bold".to_owned());
     if has_yahei {
         fonts
             .families
@@ -158,7 +159,7 @@ pub fn apply_fonts(ctx: &egui::Context) {
         .families
         .entry(egui::FontFamily::Monospace)
         .or_default()
-        .insert(0, "MapleMono-NF-CN-Bold".to_owned());
+        .insert(0, "Hack-Bold".to_owned());
     if has_yahei {
         fonts
             .families
@@ -174,7 +175,7 @@ pub fn panel_frame(ctx: &egui::Context) -> egui::Frame {
     let style = ctx.global_style();
     egui::Frame::window(&style)
         .fill(ONE_DARK_PRO.panel)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(ONE_DARK_PRO.radius))
         .inner_margin(egui::Margin::same(METRICS.panel_padding))
         .shadow(egui::epaint::Shadow {
@@ -198,7 +199,7 @@ pub fn center_panel_frame() -> egui::Frame {
 pub fn group_frame() -> egui::Frame {
     egui::Frame::new()
         .fill(ONE_DARK_PRO.panel_deep)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft))
         .corner_radius(egui::CornerRadius::same(4))
         .inner_margin(egui::Margin::symmetric(
             METRICS.group_padding_x,
@@ -209,7 +210,7 @@ pub fn group_frame() -> egui::Frame {
 pub fn tag_button(label: impl Into<egui::WidgetText>) -> egui::Button<'static> {
     egui::Button::new(label)
         .fill(ONE_DARK_PRO.panel_strong)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(0.0, METRICS.button_height))
 }
@@ -222,7 +223,7 @@ pub fn rich_tag_button(
 
     egui::Button::new(text)
         .fill(ONE_DARK_PRO.panel_strong)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(0.0, METRICS.button_height))
 }
@@ -230,7 +231,7 @@ pub fn rich_tag_button(
 pub fn primary_button(label: impl Into<egui::WidgetText>) -> egui::Button<'static> {
     egui::Button::new(label)
         .fill(ONE_DARK_PRO.accent)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.accent_hot))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.accent_hot))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(112.0, METRICS.button_height))
 }
@@ -239,7 +240,7 @@ pub fn danger_button(label: impl Into<egui::WidgetText>) -> egui::Button<'static
     egui::Button::new(label)
         .fill(ACCENT_RED)
         .stroke(egui::Stroke::new(
-            1.0_f32,
+            1.0,
             egui::Color32::from_rgb(255, 138, 126),
         ))
         .corner_radius(egui::CornerRadius::same(4))
@@ -252,7 +253,7 @@ pub fn accent_button(
 ) -> egui::Button<'static> {
     egui::Button::new(label)
         .fill(fill)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(0.0, METRICS.button_height))
 }
@@ -271,7 +272,7 @@ pub fn mode_button(label: &'static str, selected: bool) -> egui::Button<'static>
 
     egui::Button::new(egui::RichText::new(label).color(egui::Color32::WHITE))
         .fill(fill)
-        .stroke(egui::Stroke::new(1.0_f32, stroke))
+        .stroke(egui::Stroke::new(1.0, stroke))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(96.0, METRICS.button_height))
 }
@@ -279,7 +280,7 @@ pub fn mode_button(label: &'static str, selected: bool) -> egui::Button<'static>
 pub fn icon_button<'a>(icon: impl Into<egui::WidgetText>, size: egui::Vec2) -> egui::Button<'a> {
     egui::Button::new(icon)
         .fill(ONE_DARK_PRO.panel_strong)
-        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(size)
 }

src/texture.rs

@@ -187,7 +187,6 @@ impl Texture {
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn from_rgba8_with_sampler(
         device: &wgpu::Device,
         queue: &wgpu::Queue,

src/theme.rs

@@ -83,6 +83,53 @@ pub fn apply_theme(ctx: &egui::Context, theme: &AppTheme) {
     ctx.set_global_style(style);
 }
 
+pub fn apply_fonts(ctx: &egui::Context) {
+    let mut fonts = egui::FontDefinitions::default();
+
+    fonts.font_data.insert(
+        "Hack-Bold".to_owned(),
+        egui::FontData::from_static(include_bytes!("../static/Hack-Bold.ttf")).into(),
+    );
+
+    let has_yahei = std::fs::read(r"C:\Windows\Fonts\msyh.ttc")
+        .or_else(|_| std::fs::read(r"C:\Windows\Fonts\msyhbd.ttc"))
+        .map(|font_data| {
+            fonts.font_data.insert(
+                "Microsoft-YaHei".to_owned(),
+                egui::FontData::from_owned(font_data).into(),
+            );
+        })
+        .is_ok();
+
+    fonts
+        .families
+        .entry(egui::FontFamily::Proportional)
+        .or_default()
+        .insert(0, "Hack-Bold".to_owned());
+    if has_yahei {
+        fonts
+            .families
+            .entry(egui::FontFamily::Proportional)
+            .or_default()
+            .push("Microsoft-YaHei".to_owned());
+    }
+
+    fonts
+        .families
+        .entry(egui::FontFamily::Monospace)
+        .or_default()
+        .insert(0, "Hack-Bold".to_owned());
+    if has_yahei {
+        fonts
+            .families
+            .entry(egui::FontFamily::Monospace)
+            .or_default()
+            .push("Microsoft-YaHei".to_owned());
+    }
+
+    ctx.set_fonts(fonts);
+}
+
 pub fn panel_frame(ctx: &egui::Context) -> egui::Frame {
     let style = ctx.global_style();
     egui::Frame::window(&style)

src/ui.rs

@@ -7,9 +7,7 @@ use crate::{
     serial_core::serial::{SerialIoStats, SerialProtocol},
     style::{
         self, ACCENT_BLUE, ACCENT_GREEN, ACCENT_ORANGE, ACCENT_RED, METRICS, ONE_DARK_PRO,
-        dim_text, group_frame,
+        dim_text, group_frame, layout, panel_frame, rich_tag_button, tag_button,
-        layout::{self},
-        panel_frame, rich_tag_button, tag_button,
     },
     utils::serial_enum,
 };
@@ -53,7 +51,6 @@ pub struct ConnectPanelState {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum SerialMode {
     Finger,
-    Finger3D,
     Hand,
 }
 
@@ -61,26 +58,16 @@ impl SerialMode {
     pub fn baud_rate(self) -> u32 {
         match self {
             SerialMode::Finger => 921_600,
-            SerialMode::Finger3D => 921_600,
+            SerialMode::Hand => 1_152_000,
-            SerialMode::Hand => 921_600,
         }
     }
 
     pub fn protocol(self) -> SerialProtocol {
         match self {
             SerialMode::Finger => SerialProtocol::TactileA,
-            SerialMode::Finger3D => SerialProtocol::TactileA,
             SerialMode::Hand => SerialProtocol::HandGateway,
         }
     }
-
-    pub fn matrix_shape(self) -> (u32, u32) {
-        match self {
-            SerialMode::Finger => (12, 7),
-            SerialMode::Finger3D => (12, 9),
-            SerialMode::Hand => (12, 7),
-        }
-    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -114,7 +101,7 @@ impl Default for ConfigPanelState {
         let port = available_ports
             .first()
             .cloned()
-            .unwrap_or_else(|| "无可用串口".to_owned());
+            .unwrap_or_else(|| "COM3".to_owned());
 
         Self {
             mode: SerialMode::Finger,
@@ -170,7 +157,7 @@ fn responsive_panel_width(ctx: &egui::Context, preferred: f32, min_width: f32) -
 
 fn responsive_panel_height(ctx: &egui::Context, preferred: f32, min_height: f32) -> f32 {
     let screen = ctx.content_rect();
-    let available = (screen.height() - layout::TITLE_BAR_HEIGHT - PANEL_VIEWPORT_MARGIN * 2.0)
+    let available = (screen.height() - layout::WORKSPACE_TOP - PANEL_VIEWPORT_MARGIN * 2.0)
         .max(min_height.min(screen.height()));
     let height_cap = (screen.height() * 0.72).max(min_height.min(available));
 
@@ -186,7 +173,7 @@ fn responsive_panel_pos(
     panel_width: f32,
 ) -> egui::Pos2 {
     let rect = viewport_panel_rect(ctx);
-    let min_y = rect.top() + layout::TITLE_BAR_HEIGHT + PANEL_VIEWPORT_MARGIN;
+    let min_y = rect.top() + layout::WORKSPACE_TOP + PANEL_VIEWPORT_MARGIN;
     let max_x = (rect.right() - panel_width).max(rect.left());
     let preferred_right_side = preferred.x > rect.center().x;
     let x = if preferred_right_side {
@@ -254,8 +241,8 @@ pub fn draw_connect_panel(
 
                         ui.vertical(|ui| {
                             draw_connect_port_row(ui, config);
-                            // ui.add_space(8.0);
+                            ui.add_space(6.0);
-                            // draw_connect_matrix_row(ui, config);
+                            draw_connect_matrix_row(ui, config);
                         });
                     });
                 });
@@ -310,13 +297,14 @@ fn draw_connect_port_row(ui: &mut egui::Ui, config: &mut ConnectPanelState) {
             ))
             .on_hover_text("刷新串口")
             .clicked()
-            && let Ok(ports) = serial_enum()
         {
+            if let Ok(ports) = serial_enum() {
                 if !ports.contains(&config.selected_port) {
                     config.selected_port = ports.first().cloned().unwrap_or_default();
                 }
                 config.port = ports;
             }
+        }
 
         ui.add_space(METRICS.item_gap);
         ui.label(style::field_label("频率"));
@@ -397,16 +385,15 @@ fn draw_connect_action_row(
     });
 }
 
-#[allow(clippy::too_many_arguments)]
 pub fn draw_config_panel(
     ctx: &egui::Context,
     panel: &mut FloatingPanelState,
     config: &mut ConfigPanelState,
     connection: &ConnectionManager,
     recorder: &Recorder,
-    _state: SerialIoStats,
+    stats: SerialIoStats,
-    _sample_rate_hz: f32,
+    sample_rate_hz: f32,
-    _render_rate_hz: f32,
+    render_rate_hz: f32,
 ) -> Option<SerialMode> {
     let mut changed_mode = None;
     let conn_state = connection.state();
@@ -415,6 +402,7 @@ pub fn draw_config_panel(
         screen.left_top() + egui::vec2(0.0, layout::TITLE_BAR_HEIGHT),
         egui::vec2(screen.width(), layout::CONFIG_BAR_HEIGHT),
     );
+
     config.connected = matches!(
         conn_state,
         ConnectionState::Connected | ConnectionState::Streaming
@@ -444,65 +432,34 @@ pub fn draw_config_panel(
                     ui.add_space(12.0);
                     draw_config_bar_connection(ui, config, connection, recorder, conn_state);
 
-                    // ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                    //     draw_conf
+                        draw_config_bar_rates(ui, stats, sample_rate_hz, render_rate_hz);
-                    // })
+                    });
-                })
+                });
-            })
+            });
         });
 
-    // let stats = connection.stats();
-    // let panel_width = responsive_panel_width(ctx, 560.0, 340.0);
-    // config.connected = matches!(
-    //     conn_state,
-    //     ConnectionState::Connected | ConnectionState::Streaming
-    // );
-
-    // draw_floating_panel(ctx, panel, "配置", "config_panel", 560.0, 340.0, |ui| {
-    //     ui.set_min_width(panel_width);
-    //     ui.set_max_width(panel_width);
-
-    //     if let Some(mode) = draw_mode_row(ui, config) {
-    //         changed_mode = Some(mode);
-    //     }
-
-    //     // draw_mode_row(ui, config);
-    //     ui.separator();
-    //     draw_connection_row(ui, config, connection, recorder, conn_state);
-    //     ui.add_space(8.0);
-    //     // Legacy serial parameter grid is intentionally kept commented for future hardware:
-    //     // draw_serial_grid(ui, config);
-    //     // ui.add_space(8.0);
-    //     draw_mode_body(ui, config, conn_state, stats);
-    // });
     changed_mode
 }
 
 fn config_bar_frame() -> egui::Frame {
     egui::Frame::new()
         .fill(ONE_DARK_PRO.panel_deep)
-        .inner_margin(egui::Margin::symmetric(8, 8))
+        .inner_margin(egui::Margin::symmetric(8, 6))
 }
 
 fn draw_config_bar_mode(ui: &mut egui::Ui, config: &mut ConfigPanelState) -> Option<SerialMode> {
     let mut changed_to = None;
-    ui.horizontal_wrapped(|ui| {
+
+    ui.horizontal(|ui| {
         ui.colored_label(dim_text(), "模式");
-        ui.add_space(12.0);
 
         if mode_button(ui, &mut config.mode, SerialMode::Finger, "指尖模块") {
-            changed_to = Some(SerialMode::Finger)
+            changed_to = Some(SerialMode::Finger);
         }
-        // mode_button(ui, &mut config.mode, SerialMode::Model, "模型");
+        if mode_button(ui, &mut config.mode, SerialMode::Hand, "游戏体验") {
-
+            changed_to = Some(SerialMode::Hand);
-        if mode_button(ui, &mut config.mode, SerialMode::Finger3D, "3D指尖") {
-            changed_to = Some(SerialMode::Finger3D)
         }
-        // Legacy reconnect controls. Current sensors run fixed 921600 baud without auto-reconnect UI.
-        // ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-        //     ui.checkbox(&mut config.auto_reconnect, "自动");
-        //     ui.colored_label(dim_text(), "重连");
-        // });
     });
 
     changed_to
@@ -517,7 +474,6 @@ fn draw_config_bar_connection(
 ) {
     ui.colored_label(dim_text(), "端口");
     egui::ComboBox::from_id_salt("config_bar_ports")
-        .selected_text("config_bar_ports")
         .width(170.0)
         .selected_text(if config.port.is_empty() {
             "无可用串口".to_owned()
@@ -532,9 +488,7 @@ fn draw_config_bar_connection(
 
     if ui
         .add(style::icon_button(
-            egui::RichText::new("\u{f021}")
+            egui::RichText::new("⟳").color(ONE_DARK_PRO.text).size(16.0),
-                .color(ONE_DARK_PRO.text)
-                .size(16.0),
             egui::vec2(30.0, METRICS.field_height),
         ))
         .on_hover_text("刷新串口")
@@ -560,8 +514,7 @@ fn draw_config_bar_connection(
         conn_state,
         ConnectionState::Connected | ConnectionState::Streaming
     );
-
+    let button_text = if is_connected { "断开" } else { "连接" };
-    let button_text = if is_connected { "\u{f127}" } else { "\u{f0c1}" };
     if ui
         .add_sized(
             egui::vec2(88.0, METRICS.button_height),
@@ -576,11 +529,10 @@ fn draw_config_bar_connection(
         if is_connected {
             connection.disconnect();
         } else if !config.port.is_empty() {
-            let (rows, cols) = config.mode.matrix_shape();
             connection.connect(
                 &config.port,
-                rows,
+                12,
-                cols,
+                7,
                 config.mode.baud_rate(),
                 config.mode.protocol(),
                 recorder.clone(),
@@ -589,6 +541,110 @@ fn draw_config_bar_connection(
     }
 }
 
+fn draw_config_bar_rates(
+    ui: &mut egui::Ui,
+    _stats: SerialIoStats,
+    sample_rate_hz: f32,
+    render_rate_hz: f32,
+) {
+    ui.label(style::value_text(format!("{render_rate_hz:.1} Hz")));
+    ui.colored_label(dim_text(), "画面刷新率");
+    ui.add_space(14.0);
+    ui.label(style::value_text(format!("{sample_rate_hz:.1} Hz")));
+    ui.colored_label(dim_text(), "采样率");
+}
+
+pub fn draw_spatial_force_panel(
+    ctx: &egui::Context,
+    force: Option<HudSpatialForce>,
+    force_history: &[f32],
+) {
+    let Some(force) = force else {
+        return;
+    };
+
+    let target_visible = has_recent_resultant_force(force_history);
+    let anim = ctx.animate_bool(egui::Id::new("spatial_force_panel_enter"), target_visible);
+    if anim <= 0.01 {
+        return;
+    }
+
+    let target_anim = if target_visible { 1.0 } else { 0.0 };
+    if (anim - target_anim).abs() > 0.001 {
+        ctx.request_repaint();
+    }
+
+    let alpha = (anim * 242.0).round() as u8;
+    let panel_width = responsive_panel_width(ctx, 380.0, 260.0);
+    let panel_height = responsive_panel_height(ctx, 340.0, 220.0);
+    let viewport = viewport_panel_rect(ctx);
+    let pos = egui::pos2(
+        viewport.right() - panel_width,
+        viewport.bottom() - panel_height - PANEL_VIEWPORT_MARGIN,
+    );
+
+    egui::Area::new(egui::Id::new("spatial_force_panel"))
+        .fixed_pos(pos)
+        .constrain_to(viewport)
+        .order(egui::Order::Foreground)
+        .show(ctx, |ui| {
+            faded_panel_frame(ctx, alpha).show(ui, |ui| {
+                ui.set_min_width(panel_width);
+                ui.set_max_width(panel_width);
+                ui.set_min_height(panel_height);
+
+                let text_dim = color_alpha(ONE_DARK_PRO.text_dim, alpha);
+                let accent = color_alpha(ACCENT_ORANGE, alpha);
+                let green = color_alpha(ACCENT_GREEN, alpha);
+
+                ui.horizontal(|ui| {
+                    ui.colored_label(accent, "3D FORCE");
+                    ui.label(egui::RichText::new("三维力方向").color(text_dim).size(17.0));
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                        ui.colored_label(
+                            green,
+                            egui::RichText::new("LIVE").color(green).size(12.0),
+                        );
+                    });
+                });
+                ui.separator();
+
+                ui.vertical_centered(|ui| {
+                    let gauge_size = (panel_height - 52.0).min(panel_width - 24.0).max(168.0);
+                    let (rect, _) = ui.allocate_exact_size(
+                        egui::vec2(gauge_size, gauge_size),
+                        egui::Sense::hover(),
+                    );
+                    paint_spatial_force_gauge(ui.painter(), rect, force, alpha);
+                });
+            });
+        });
+}
+
+fn draw_mode_row(ui: &mut egui::Ui, config: &mut ConfigPanelState) -> Option<SerialMode> {
+    let mut changed_to = None;
+    ui.horizontal_wrapped(|ui| {
+        ui.colored_label(dim_text(), "模式");
+        ui.add_space(12.0);
+
+        if mode_button(ui, &mut config.mode, SerialMode::Finger, "指尖模块") {
+            changed_to = Some(SerialMode::Finger)
+        }
+        if mode_button(ui, &mut config.mode, SerialMode::Hand, "游戏体验") {
+            changed_to = Some(SerialMode::Hand)
+        }
+        // mode_button(ui, &mut config.mode, SerialMode::Model, "模型");
+
+        // Legacy reconnect controls. Current sensors run fixed 921600 baud without auto-reconnect UI.
+        // ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+        //     ui.checkbox(&mut config.auto_reconnect, "自动");
+        //     ui.colored_label(dim_text(), "重连");
+        // });
+    });
+
+    changed_to
+}
+
 fn draw_connection_row(
     ui: &mut egui::Ui,
     config: &mut ConfigPanelState,
@@ -601,7 +657,7 @@ fn draw_connection_row(
         ui.horizontal_wrapped(|ui| {
             ui.label(style::field_label("端口"));
             egui::ComboBox::from_id_salt("config_ports")
-                .width(ui.available_width().clamp(104.0, 150.0))
+                .width(ui.available_width().min(150.0).max(104.0))
                 .selected_text(if config.port.is_empty() {
                     "无可用串口".to_owned()
                 } else {
@@ -648,11 +704,10 @@ fn draw_connection_row(
             if is_connected {
                 connection.disconnect();
             } else if !config.port.is_empty() {
-                let (rows, cols) = config.mode.matrix_shape();
                 connection.connect(
                     &config.port,
-                    rows,
+                    12,
-                    cols,
+                    7,
                     config.mode.baud_rate(),
                     config.mode.protocol(),
                     recorder.clone(),
@@ -754,50 +809,22 @@ fn draw_mode_body(
     config: &mut ConfigPanelState,
     conn_state: ConnectionState,
     stats: SerialIoStats,
+    sample_rate_hz: f32,
+    render_rate_hz: f32,
 ) {
-    group_frame().show(ui, |ui| match config.mode {
+    let _ = (config.mode, conn_state, stats);
-        SerialMode::Finger => {
+    draw_realtime_rate_row(ui, sample_rate_hz, render_rate_hz);
-            // Legacy module-address controls for older devices:
+}
-            // ui.horizontal(|ui| {
+
-            //     ui.label(style::field_label("模块地址"));
+fn draw_realtime_rate_row(ui: &mut egui::Ui, sample_rate_hz: f32, render_rate_hz: f32) {
-            //     ui.add_sized(
+    group_frame().show(ui, |ui| {
-            //         egui::vec2(80.0, METRICS.field_height),
+        ui.horizontal_wrapped(|ui| {
-            //         egui::DragValue::new(&mut config.module_addr).range(1..=247),
+            ui.colored_label(dim_text(), "实时采样率");
-            //     );
+            ui.label(style::value_text(format!("{sample_rate_hz:.1} Hz")));
-            //     ui.add_space(16.0);
+            ui.add_space(18.0);
-            //     if ui.add(tag_button("读取信息")).clicked() {}
+            ui.colored_label(dim_text(), "画面刷新率");
-            //     if ui.add(tag_button("探测")).clicked() {}
+            ui.label(style::value_text(format!("{render_rate_hz:.1} Hz")));
-            // });
+        });
-            draw_status_bytes_row(ui, conn_state, stats);
-        }
-        SerialMode::Finger3D => {
-            draw_status_bytes_row(ui, conn_state, stats);
-        }
-        SerialMode::Hand => {
-            // Legacy manual-TX controls for older hand-module debugging:
-            // ui.horizontal(|ui| {
-            //     ui.label(style::field_label("发送"));
-            //     ui.add_sized(
-            //         egui::vec2(300.0, METRICS.field_height),
-            //         egui::TextEdit::singleline(&mut config.manual_tx),
-            //     );
-            //     if ui.add(tag_button("发送")).clicked() {}
-            //     if ui.add(tag_button("清空")).clicked() {
-            //         config.manual_tx.clear();
-            //     }
-            // });
-            draw_status_bytes_row(ui, conn_state, stats);
-        } // SerialMode::Model => {
-          //     ui.horizontal(|ui| {
-          //         ui.label(style::field_label("模型"));
-          //         ui.add_sized(
-          //             egui::vec2(300.0, METRICS.field_height),
-          //             egui::TextEdit::singleline(&mut config.model_path),
-          //         );
-          //         if ui.add(tag_button("加载")).clicked() {}
-          //         if ui.add(tag_button("运行")).clicked() {}
-          //     });
-          // }
     });
 }
 
@@ -865,7 +892,7 @@ pub fn icon_button_sized<'a>(
         ),
     }
     .fill(ONE_DARK_PRO.panel_strong)
-    .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+    .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
     .corner_radius(egui::CornerRadius::same(ONE_DARK_PRO.radius))
     .min_size(size);
 
@@ -947,7 +974,7 @@ pub fn draw_stats_panel(
     let target_pos = egui::pos2(
         viewport.left(),
         (viewport.bottom() - panel_height - PANEL_VIEWPORT_MARGIN * 2.0)
-            .max(viewport.top() + layout::TITLE_BAR_HEIGHT + PANEL_VIEWPORT_MARGIN),
+            .max(viewport.top() + layout::WORKSPACE_TOP + PANEL_VIEWPORT_MARGIN),
     );
     let target_x = target_pos.x;
     let hidden_x = if target_x < screen.center().x {
@@ -984,17 +1011,14 @@ const HAND_FORCE_PANEL_MAX_HEIGHT: f32 = 190.0;
 const HAND_FORCE_PANEL_GAP: f32 = 12.0;
 const HAND_FORCE_PANEL_SIDE_MARGIN: f32 = 24.0;
 const HAND_FORCE_PANEL_VERTICAL_MARGIN: f32 = 28.0;
-const HAND_FORCE_PANEL_TITLES: [(&str, &str); 10] = [
+const HAND_FORCE_PANEL_TITLES: [(&str, &str); 7] = [
-    ("T", "顶部 2×4"),
+    ("T1", "拇指"),
-    ("L3", "左侧 3×1"),
+    ("T2", "食指"),
-    ("L5", "左侧 5×1"),
+    ("T3", "中指"),
-    ("L8", "左侧 8×1"),
+    ("T4", "无名指"),
-    ("L10", "左侧 10×1"),
+    ("T5", "小指"),
-    ("C", "中央 11×4"),
+    ("P1", "掌心横区"),
-    ("R3", "右侧 3×1"),
+    ("P2", "掌心纵区"),
-    ("R5", "右侧 5×1"),
-    ("R8", "右侧 8×1"),
-    ("R10", "右侧 10×1"),
 ];
 
 fn has_recent_resultant_force(values: &[f32]) -> bool {
@@ -1020,10 +1044,10 @@ pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[V
         .max(HAND_FORCE_PANEL_MIN_WIDTH.min(side_width));
     let left_x = screen.left() + side_margin;
     let right_x = screen.right() - side_margin - panel_width;
-    let left_count = 5usize;
+    let left_count = 4usize;
     let right_count = HAND_FORCE_PANEL_TITLES.len() - left_count;
     let available_height =
-        (screen.height() - layout::TITLE_BAR_HEIGHT - vertical_margin * 2.0).max(0.0);
+        (screen.height() - layout::WORKSPACE_TOP - vertical_margin * 2.0).max(0.0);
     let panel_height = ((available_height - (left_count - 1) as f32 * gap) / left_count as f32)
         .clamp(
             HAND_FORCE_PANEL_MIN_HEIGHT.min(available_height),
@@ -1032,12 +1056,13 @@ pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[V
     let left_height = left_count as f32 * panel_height + (left_count - 1) as f32 * gap;
     let right_height =
         right_count as f32 * panel_height + (right_count.saturating_sub(1)) as f32 * gap;
-    let min_top = screen.top() + layout::TITLE_BAR_HEIGHT + vertical_margin;
+    let min_top = screen.top() + layout::WORKSPACE_TOP + vertical_margin;
     let left_top = (screen.center().y - left_height * 0.5).max(min_top);
     let right_top = (screen.center().y - right_height * 0.5).max(min_top);
 
-    for (index, &(code, title)) in HAND_FORCE_PANEL_TITLES.iter().enumerate() {
+    for index in 0..HAND_FORCE_PANEL_TITLES.len() {
         let history = histories.get(index).map(Vec::as_slice).unwrap_or(&[]);
+        let (code, title) = HAND_FORCE_PANEL_TITLES[index];
         let (target_x, target_y) = if index < left_count {
             (left_x, left_top + index as f32 * (panel_height + gap))
         } else {
@@ -1061,7 +1086,6 @@ pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[V
     }
 }
 
-#[allow(clippy::too_many_arguments)]
 fn draw_force_chart_area(
     ctx: &egui::Context,
     id: egui::Id,
@@ -1138,7 +1162,7 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
     painter.rect_stroke(
         rect,
         radius,
-        egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.accent, 95)),
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 95)),
         egui::StrokeKind::Outside,
     );
 
@@ -1166,9 +1190,7 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
         .ctx()
         .animate_bool(egui::Id::new("resultant_force_chart_enter"), true);
     let slide_offset = (1.0 - enter) * -chart_rect.width() * 0.65;
-    let tick_phase = (time / FORCE_CHART_SAMPLE_SECONDS).fract();
+    let plot_rect = chart_rect.translate(egui::vec2(slide_offset, 0.0));
-    let scroll_offset = -tick_phase * chart_rect.width() / CHART_POINTS.max(1) as f32;
-    let plot_rect = chart_rect.translate(egui::vec2(slide_offset + scroll_offset, 0.0));
 
     let mut points = Vec::with_capacity(values.len());
     let start_slot = CHART_POINTS.saturating_sub(values.len());
@@ -1187,11 +1209,11 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
     if points.len() >= 2 {
         plot_painter.add(egui::Shape::line(
             points.clone(),
-            egui::Stroke::new(4.0_f32, color_alpha(ONE_DARK_PRO.accent, 45)),
+            egui::Stroke::new(4.0, color_alpha(ONE_DARK_PRO.accent, 45)),
         ));
         plot_painter.add(egui::Shape::line(
             points.clone(),
-            egui::Stroke::new(1.7_f32, ONE_DARK_PRO.accent),
+            egui::Stroke::new(1.7, ONE_DARK_PRO.accent),
         ));
     }
 
@@ -1201,7 +1223,7 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
             last,
             5.0 + pulse * 12.0,
             egui::Stroke::new(
-                1.0_f32,
+                1.0,
                 color_alpha(ACCENT_GREEN, ((1.0 - pulse) * 120.0) as u8),
             ),
         );
@@ -1225,7 +1247,7 @@ fn paint_force_grid(
                 egui::pos2(chart_rect.left(), y),
                 egui::pos2(chart_rect.right(), y),
             ],
-            egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.border, 78)),
+            egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border, 78)),
         );
         painter.text(
             egui::pos2(rect.left() + 8.0, y),
@@ -1243,7 +1265,7 @@ fn paint_force_grid(
                 egui::pos2(x, chart_rect.top()),
                 egui::pos2(x, chart_rect.bottom()),
             ],
-            egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.border_soft, 42)),
+            egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, 42)),
         );
     }
 
@@ -1295,6 +1317,126 @@ fn color_alpha(color: egui::Color32, alpha: u8) -> egui::Color32 {
     egui::Color32::from_rgba_premultiplied(color.r(), color.g(), color.b(), alpha)
 }
 
+fn faded_panel_frame(ctx: &egui::Context, alpha: u8) -> egui::Frame {
+    let style = ctx.global_style();
+    egui::Frame::window(&style)
+        .fill(color_alpha(ONE_DARK_PRO.panel, alpha))
+        .stroke(egui::Stroke::new(
+            1.0,
+            color_alpha(ONE_DARK_PRO.border, alpha),
+        ))
+        .corner_radius(egui::CornerRadius::same(ONE_DARK_PRO.radius))
+        .inner_margin(egui::Margin::same(METRICS.panel_padding))
+        .shadow(egui::epaint::Shadow {
+            offset: [0, 14],
+            blur: 28,
+            spread: 0,
+            color: egui::Color32::from_black_alpha((alpha as f32 * 0.45) as u8),
+        })
+}
+
+fn paint_spatial_force_gauge(
+    painter: &egui::Painter,
+    rect: egui::Rect,
+    force: HudSpatialForce,
+    alpha: u8,
+) {
+    let center = rect.center();
+    let radius = rect.width().min(rect.height()) * 0.42;
+    let angle = force.angle_deg.to_radians();
+    let direction = egui::vec2(angle.cos(), angle.sin());
+    let magnitude = force.magnitude.clamp(0.0, 1.0);
+    let end = center + direction * (radius * (0.35 + magnitude * 0.65));
+    let side = egui::vec2(-direction.y, direction.x);
+
+    painter.circle_stroke(
+        center,
+        radius,
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border, alpha)),
+    );
+    painter.circle_stroke(
+        center,
+        radius * 0.55,
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 2)),
+    );
+    painter.line_segment(
+        [
+            center + egui::vec2(-radius, 0.0),
+            center + egui::vec2(radius, 0.0),
+        ],
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 3)),
+    );
+    painter.line_segment(
+        [
+            center + egui::vec2(0.0, -radius),
+            center + egui::vec2(0.0, radius),
+        ],
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 3)),
+    );
+    painter.circle_filled(
+        end,
+        12.0,
+        color_alpha(ACCENT_ORANGE, (alpha as f32 * 0.16) as u8),
+    );
+    painter.line_segment(
+        [center, end],
+        egui::Stroke::new(4.0, color_alpha(ACCENT_ORANGE, alpha)),
+    );
+    painter.line_segment(
+        [end, end - direction * 13.0 + side * 7.0],
+        egui::Stroke::new(3.0, color_alpha(ACCENT_ORANGE, alpha)),
+    );
+    painter.line_segment(
+        [end, end - direction * 13.0 - side * 7.0],
+        egui::Stroke::new(3.0, color_alpha(ACCENT_ORANGE, alpha)),
+    );
+    painter.circle_filled(center, 4.5, color_alpha(ONE_DARK_PRO.text_dim, alpha));
+    painter.circle_filled(end, 5.5, color_alpha(ACCENT_GREEN, alpha));
+    painter.circle_filled(end, 2.2, color_alpha(egui::Color32::WHITE, alpha));
+}
+
+fn draw_pinned_panel(
+    ctx: &egui::Context,
+    panel: &mut FloatingPanelState,
+    title: &'static str,
+    id: &'static str,
+    preferred_width: f32,
+    min_width: f32,
+    add_contents: impl FnOnce(&mut egui::Ui),
+) {
+    let panel_width = responsive_panel_width(ctx, preferred_width, min_width);
+    let max_height = responsive_panel_height(ctx, ctx.content_rect().height(), 180.0);
+    let pos = responsive_panel_pos(ctx, panel.default_pos, panel_width);
+
+    egui::Window::new(title)
+        .id(egui::Id::new(id))
+        .current_pos(pos)
+        .max_width(panel_width)
+        .max_height(max_height)
+        .constrain_to(viewport_panel_rect(ctx))
+        .title_bar(false)
+        .resizable(false)
+        .frame(panel_frame(ctx))
+        .show(ctx, |ui| {
+            ui.spacing_mut().item_spacing = egui::vec2(METRICS.item_gap, 6.0);
+            ui.set_min_width(panel_width);
+            ui.set_max_width(panel_width);
+            ui.horizontal(|ui| {
+                ui.label(style::panel_title(title));
+            });
+            ui.separator();
+            let content_max_height = (max_height - 60.0).max(120.0);
+            egui::ScrollArea::vertical()
+                .max_height(content_max_height)
+                .auto_shrink([false, true])
+                .show(ui, |ui| {
+                    ui.set_min_width(panel_width);
+                    ui.set_max_width(panel_width);
+                    add_contents(ui);
+                });
+        });
+}
+
 fn draw_floating_panel(
     ctx: &egui::Context,
     panel: &mut FloatingPanelState,
@@ -1352,7 +1494,8 @@ fn draw_floating_panel(
             window_rect = Some(response.response.rect);
         }
 
-        if hide_requested && let Some(rect) = window_rect {
+        if hide_requested {
+            if let Some(rect) = window_rect {
                 let screen = ctx.content_rect();
                 let tag_size = egui::vec2(86.0, 22.0);
 
@@ -1369,6 +1512,7 @@ fn draw_floating_panel(
 
                 panel.tag_pos = egui::pos2(x, y);
             }
+        }
         panel.visible = open && !hide_requested;
     }
     // else {
@@ -1550,11 +1694,11 @@ fn paint_integrated_handle(
         ui.painter().add(egui::Shape::convex_polygon(
             points.clone(),
             fill,
-            egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border),
+            egui::Stroke::new(1.0, ONE_DARK_PRO.border),
         ));
         ui.painter().line_segment(
             [points[2], points[3]],
-            egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
+            egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
         );
     }
 
@@ -1575,14 +1719,14 @@ fn paint_integrated_handle(
             arrow_center + egui::vec2(-6.0, -2.0 * arrow),
             arrow_center + egui::vec2(0.0, 4.0 * arrow),
         ],
-        egui::Stroke::new(1.7_f32, arrow_color),
+        egui::Stroke::new(1.7, arrow_color),
     );
     ui.painter().line_segment(
         [
             arrow_center + egui::vec2(6.0, -2.0 * arrow),
             arrow_center + egui::vec2(0.0, 4.0 * arrow),
         ],
-        egui::Stroke::new(1.7_f32, arrow_color),
+        egui::Stroke::new(1.7, arrow_color),
     );
 
     if !label.is_empty() {
@@ -1608,8 +1752,8 @@ fn paint_integrated_center_panel(
     handle_on_bottom: bool,
 ) {
     let painter = ui.painter();
-    let stroke = egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border);
+    let stroke = egui::Stroke::new(1.0, ONE_DARK_PRO.border);
-    let accent_stroke = egui::Stroke::new(1.2_f32, ONE_DARK_PRO.border_soft);
+    let accent_stroke = egui::Stroke::new(1.2, ONE_DARK_PRO.border_soft);
     let top = rect.top();
     let left = rect.left();
     let right = rect.right();
@@ -1754,7 +1898,7 @@ pub fn draw_signal_chart(ui: &mut egui::Ui, values: &[f32], label: &str, color:
             })
             .collect();
 
-        painter.add(egui::Shape::line(points, egui::Stroke::new(1.5_f32, color)));
+        painter.add(egui::Shape::line(points, egui::Stroke::new(1.5, color)));
     });
 }
 
@@ -1815,9 +1959,11 @@ pub fn draw_recording_toolbar(ui: &mut egui::Ui, recorder: &Recorder, export_pat
         ui.add_space(4.0);
 
         // Pause/Resume
-        if is_recording && ui.add(tag_button("⏸ 暂停")).clicked() {
+        if is_recording {
+            if ui.add(tag_button("⏸ 暂停")).clicked() {
                 let _ = recorder.pause_recording();
             }
+        }
 
         ui.add_space(8.0);
 

src/utils.rs

@@ -1,3 +1,4 @@
+use anyhow;
 use serialport::available_ports;
 
 pub fn serial_enum() -> anyhow::Result<Vec<String>> {

static/wgsl/shader.wgsl

@@ -349,8 +349,10 @@ fn circle_alpha(local: vec2f, radius: f32, softness: f32) -> f32 {
     return 1.0 - smoothstep(radius, radius + softness, dist);
 }
 
-// Convert a point authored in sensor-canvas UV space into aspect-fitted clip space.
+// Convert a point authored in hand.png UV space into clip space.
-fn sensor_canvas_uv_to_clip(image_uv: vec2f) -> vec2f {
+// This mirrors fs_hand_image's aspect-fit math, so fingertip dots stay attached
+// to the same image pixels when the app window changes shape.
+fn hand_image_uv_to_clip(image_uv: vec2f) -> vec2f {
     let viewport_aspect = u.viewport.x / max(u.viewport.y, 1.0);
     let image_aspect = u.image.x / max(u.image.y, 1.0);
 
@@ -418,7 +420,7 @@ fn vs_hand_membrane(vertex: DotVertexInput, instance: DotInstanceInput) -> HandM
     let image_uv = (center_px + rotate_2d(local_px, angle)) / max(u.image.xy, vec2f(1.0, 1.0));
 
     var out: HandMembraneVertexOutput;
-    out.clip_position = vec4f(sensor_canvas_uv_to_clip(image_uv), 0.0, 1.0);
+    out.clip_position = vec4f(hand_image_uv_to_clip(image_uv), 0.0, 1.0);
     out.local = vertex.local;
     return out;
 }
@@ -468,7 +470,7 @@ fn vs_hand_dot(vertex: DotVertexInput, instance: DotInstanceInput) -> DotVertexO
     let shaped = smoothstep(0.0, 1.0, intensity);
 
     // Hand instances store hand.png UV in world_position.xy instead of 3D world space.
-    let center = sensor_canvas_uv_to_clip(instance.world_position.xy);
+    let center = hand_image_uv_to_clip(instance.world_position.xy);
     // Hand fingertip matrices are much smaller than the full Finger view.
     // Keep each bead below the local cell spacing so the 12x7 matrix remains visibly separated.
     let pixel_size = u.glyph.x * mix(0.22, 0.34, shaped);
@@ -498,14 +500,75 @@ fn fs_hand_dot(in: DotVertexOutput) -> @location(0) vec4f {
     return output_color(color, max(core, halo));
 }
 
+fn chip_pixel_alpha(local: vec2f, half_size: f32, softness: f32) -> f32 {
+    let q = abs(local) - vec2f(half_size, half_size);
+    let dist = length(max(q, vec2f(0.0, 0.0))) + min(max(q.x, q.y), 0.0);
+    return 1.0 - smoothstep(0.0, softness, dist);
+}
+
+struct HandPalmChipVertexOutput {
+    @builtin(position) clip_position: vec4f,
+    @location(0) local: vec2f,
+    @location(1) grid: vec2f,
+}
+
+@vertex
+fn vs_hand_palm_chip(vertex: DotVertexInput, instance: DotInstanceInput) -> HandPalmChipVertexOutput {
+    let center_px = instance.world_position.xy * u.image.xy;
+    let size_px = instance.style.yz;
+    let angle = instance.style.x;
+    let packed_shape = instance.style.w;
+    let shape_rows = floor(packed_shape / 100.0);
+    let shape_cols = max(packed_shape - shape_rows * 100.0, 1.0);
+    let local_px = vertex.local * size_px * 0.5;
+    let image_uv = (center_px + rotate_2d(local_px, angle)) / max(u.image.xy, vec2f(1.0, 1.0));
+
+    var out: HandPalmChipVertexOutput;
+    out.clip_position = vec4f(hand_image_uv_to_clip(image_uv), 0.0, 1.0);
+    out.local = vertex.local;
+    out.grid = vec2f(shape_cols, max(shape_rows, 1.0));
+    return out;
+}
+
+@fragment
+fn fs_hand_palm_chip(in: HandPalmChipVertexOutput) -> @location(0) vec4f {
+    // Dark rounded tile: this is the inset chip body sitting inside the palm surface.
+    let panel = rounded_rect_alpha(in.local, 0.10, 0.040);
+    let inset = rounded_rect_alpha(in.local * vec2f(1.10, 1.08), 0.08, 0.052);
+    let rim = clamp(panel - inset * 0.72, 0.0, 1.0);
+
+    // Inactive chip pixels use the chip's real hand layout:
+    // horizontal 14 columns x 5 rows, or vertical 4 columns x 11 rows.
+    let uv = clamp(in.local * 0.5 + vec2f(0.5, 0.5), vec2f(0.0, 0.0), vec2f(1.0, 1.0));
+    let cell = abs(fract(uv * in.grid) - vec2f(0.5, 0.5));
+    let micro_pixel = 1.0 - smoothstep(0.105, 0.178, length(cell * vec2f(1.04, 0.94)));
+
+    let top_bevel = smoothstep(-0.96, -0.18, -in.local.y) * 0.16;
+    let lower_shadow = smoothstep(0.20, 0.92, in.local.y) * 0.22;
+    let side_bevel = smoothstep(0.58, 0.96, abs(in.local.x)) * 0.12;
+    let scan = (0.5 + 0.5 * sin((uv.y * 36.0 + uv.x * 7.0) * 6.28318)) * 0.026;
+
+    let base = vec3f(0.004, 0.012, 0.018);
+    let glass = vec3f(0.012, 0.048, 0.064);
+    let pixel_color = vec3f(0.075, 0.300, 0.360);
+    let rim_color = vec3f(0.060, 0.560, 0.670);
+    let color = base * (0.92 - lower_shadow)
+        + glass * (0.52 + top_bevel + side_bevel + scan)
+        + pixel_color * micro_pixel * 0.70
+        + rim_color * rim * 0.60;
+
+    let alpha = panel * (0.64 + micro_pixel * 0.18 + rim * 0.20);
+    return output_color(color, alpha);
+}
+
 @vertex
 fn vs_hand_palm_dot(vertex: DotVertexInput, instance: DotInstanceInput) -> DotVertexOutput {
     let intensity = saturate(instance.style.x);
     let shaped = smoothstep(0.0, 1.0, intensity);
 
-    // Use the same on-screen point size as Finger mode.
+    // Palm chip pixels are deliberately smaller than fingertip beads so they read as a chip matrix.
-    let center = sensor_canvas_uv_to_clip(instance.world_position.xy);
+    let center = hand_image_uv_to_clip(instance.world_position.xy);
-    let pixel_size = u.glyph.x * mix(1.07, 2.23, shaped);
+    let pixel_size = u.glyph.x * mix(0.13, 0.25, shaped);
     let ndc_offset = vertex.local * vec2f(pixel_size / u.viewport.x, pixel_size / u.viewport.y) * 2.0;
 
     var out: DotVertexOutput;
@@ -518,11 +581,16 @@ fn vs_hand_palm_dot(vertex: DotVertexInput, instance: DotInstanceInput) -> DotVe
 @fragment
 fn fs_hand_palm_dot(in: DotVertexOutput) -> @location(0) vec4f {
     let intensity = saturate(in.intensity);
-    let base_color = sample_range_color(intensity);
+    let pixel = chip_pixel_alpha(in.local, 0.52, 0.070);
+    let glow = circle_alpha(in.local, 0.95, 0.22) * intensity * 0.36;
 
-    let alpha = circle_alpha(in.local, 0.46, 0.045);
+    let cold = vec3f(0.070, 0.340, 0.360);
-    let color = base_color * mix(0.86, 1.06, intensity);
+    let gradient = sample_range_color(intensity);
+    let color = mix(cold, gradient, smoothstep(0.0, 0.20, intensity))
+        * (0.58 + intensity * 1.04)
+        + gradient * glow * 0.72;
 
+    let alpha = max(pixel * (0.20 + intensity * 0.76), glow);
     return output_color(color, alpha);
 }