fix: correct 3D fingertip sampling and PCB mapping

.openclaw/settings.json

@@ -1,35 +0,0 @@
-{
-  "hooks": {
-    "pre-exec": [
-      {
-        "matcher": "",
-        "command": "scale gate pre-tool Bash --args-json \"$ARGS\" --session-id \"$SESSION_ID\""
-      },
-      {
-        "matcher": "edit|write",
-        "command": "scale gate pre-tool Edit --args-json \"$ARGS\" --session-id \"$SESSION_ID\""
-      }
-    ],
-    "post-exec": [
-      {
-        "matcher": "edit|write",
-        "command": "scale gate post-tool Edit --args-json \"$ARGS\" --exit-code \"$EXIT_CODE\" --session-id \"$SESSION_ID\""
-      },
-      {
-        "matcher": "",
-        "command": "scale gate post-tool Bash --args-json \"$ARGS\" --exit-code \"$EXIT_CODE\" --session-id \"$SESSION_ID\""
-      }
-    ],
-    "before-stop": [
-      {
-        "matcher": "",
-        "command": "scale gate before-stop --session-id \"$SESSION_ID\""
-      }
-    ]
-  },
-  "permissions": {
-    "allow": [
-      "scale:*"
-    ]
-  }
-}

Cargo.lock

@@ -1304,7 +1304,7 @@ checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
 
 [[package]]
 name = "eskin-model-player"
-version = "0.5.0"
+version = "5.0.0"
 dependencies = [
  "anyhow",
  "bytemuck",

Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "eskin-model-player"
-version = "0.5.0"
+version = "5.0.0"
 edition = "2024"
+authors = ["JOYSONQUIN"]
+description = "Desktop pressure sensor visualization and playback application."
 build = "build.rs"
 
+[package.metadata.wix]
+eula = false
+
 [dependencies]
 eframe = { version = "0.34.2", features = ["default", "wgpu", "__screenshot"] }
 env_logger = { version = "0.11.10", features = ["auto-color", "humantime"] }
@@ -22,3 +27,8 @@ gltf = "1.4.1"
 [build-dependencies]
 anyhow = "1.0.102"
 fs_extra = "1.3.0"
+
+
+[[bin]]
+name = "ESkinPlayer"
+path = "src/main.rs"

src/app.rs

@@ -3,17 +3,17 @@ use crate::connection::ConnectionManager;
 use crate::force::{ForceEstimatorState, HudSpatialForce};
 use crate::recording::Recorder;
 use crate::render::{ActiveMode, FingerMode, HandGatewayMode};
-use crate::style::{ONE_DARK_PRO, apply_fonts, apply_theme, layout};
+use crate::style::{self, ONE_DARK_PRO, apply_fonts, apply_theme, dim_text, layout};
 use crate::ui::SerialMode;
 use crate::{
-    matrix::{MATRIX_COLS, MATRIX_ROWS},
+    matrix::{MATRIX_COLS, MATRIX_ROWS, UNFOLDED_SENSOR_SEGMENT_COUNTS},
     render::{
         BackgroundRenderResources, PRESSURE_CELL_COUNT, PressureFrame, PressureSamples,
         WgpuBackgroundCallback,
     },
     ui::{
         ConfigPanelState, ConnectPanelState, FloatingPanelState, MatrixConfigState,
-        draw_config_panel, draw_export_panel, draw_matrix_config_panel, draw_stats_panel,
+        draw_config_panel, draw_export_panel, draw_hand_force_panels, draw_stats_panel,
         panel_restore_item,
     },
 };
@@ -21,6 +21,8 @@ use eframe::{egui, egui_wgpu};
 use std::sync::Arc;
 
 const SUMMARY_POINTS_PER_SERIES: usize = 42;
+const HAND_FORCE_PANEL_COUNT: usize = UNFOLDED_SENSOR_SEGMENT_COUNTS.len();
+const HAND_FORCE_SEGMENT_COUNTS: [usize; HAND_FORCE_PANEL_COUNT] = UNFOLDED_SENSOR_SEGMENT_COUNTS;
 
 pub struct EskinDesktopApp {
     connect_panel: FloatingPanelState,
@@ -39,6 +41,7 @@ pub struct EskinDesktopApp {
     matrix_config_panel: FloatingPanelState,
     matrix_config: MatrixConfigState,
     signal_history: Vec<f32>,
+    hand_signal_histories: [Vec<f32>; HAND_FORCE_PANEL_COUNT],
     force_estimator: ForceEstimatorState,
     latest_spatial_force: Option<HudSpatialForce>,
     latest_raw_matrix: Vec<u32>,
@@ -104,6 +107,7 @@ impl EskinDesktopApp {
             ),
             matrix_config: MatrixConfigState::default(),
             signal_history: Vec::with_capacity(128),
+            hand_signal_histories: std::array::from_fn(|_| Vec::with_capacity(128)),
             force_estimator: ForceEstimatorState::new(),
             latest_spatial_force: None,
             latest_raw_matrix: Vec::new(),
@@ -155,15 +159,15 @@ 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, glow));
-        painter.line_segment([center, end], egui::Stroke::new(2.4, color));
+        painter.line_segment([center, end], egui::Stroke::new(9.0_f32, glow));
+        painter.line_segment([center, end], egui::Stroke::new(2.4_f32, color));
         painter.line_segment(
             [end, end - direction * 14.0 + side * 7.0],
-            egui::Stroke::new(2.4, color),
+            egui::Stroke::new(2.4_f32, color),
         );
         painter.line_segment(
             [end, end - direction * 14.0 - side * 7.0],
-            egui::Stroke::new(2.4, color),
+            egui::Stroke::new(2.4_f32, color),
         );
         painter.circle_filled(center, 4.2, color);
     }
@@ -214,6 +218,12 @@ 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,
@@ -226,9 +236,6 @@ impl EskinDesktopApp {
             self.latest_matrix_rows = sample.rows;
             self.latest_matrix_cols = sample.cols;
 
-            // Feed data to recorder
-            self.recorder.add_frame(&sample.matrix);
-
             self.latest_spatial_force = self.force_estimator.analyze(&sample.matrix);
 
             // Keep JE-Skin's summary path separate from the optional spatial-force vector.
@@ -260,7 +267,7 @@ impl EskinDesktopApp {
         );
         ui.painter().line_segment(
             [title_bar_rect.left_bottom(), title_bar_rect.right_bottom()],
-            egui::Stroke::new(1.0, ONE_DARK_PRO.border),
+            egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border),
         );
 
         // Drag-to-move: double-click to maximize, drag to move
@@ -301,14 +308,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, egui::Color32::from_rgb(80, 0, 0)),
+                egui::Stroke::new(1.5_f32, 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, egui::Color32::from_rgb(80, 0, 0)),
+                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(80, 0, 0)),
             );
         }
         if close_resp.clicked() {
@@ -327,7 +334,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, egui::Color32::from_rgb(120, 80, 0)),
+                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(120, 80, 0)),
             );
         }
         if min_resp.clicked() {
@@ -346,7 +353,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, egui::Color32::from_rgb(0, 80, 10)),
+                egui::Stroke::new(1.5_f32, egui::Color32::from_rgb(0, 80, 10)),
                 egui::StrokeKind::Outside,
             );
         }
@@ -357,29 +364,58 @@ impl EskinDesktopApp {
         }
     }
 
-    fn draw_floating_panels(&mut self, ctx: &egui::Context) {
+    fn draw_floating_panels(
+        &mut self,
+        ctx: &egui::Context,
+        stats: crate::serial_core::serial::SerialIoStats,
+    ) {
         // draw_scene_panel(ctx, &mut self.scene_panel);
+        // if self.config_state.mode == SerialMode::Hand && self.stats_panel.visible {
+        //     self.config_panel.visible = false;
+        //     self.export_panel.visible = false;
+        //     self.matrix_config_panel.visible = false;
+        // }
+
         if let Some(next_mode) = draw_config_panel(
             ctx,
             &mut self.config_panel,
             &mut self.config_state,
             &self.connection,
+            &self.recorder,
+            stats,
+            100.0,
+            100.0,
         ) {
             self.switch_mode(next_mode);
         }
+        match self.config_state.mode {
+            SerialMode::Finger => {
                 draw_stats_panel(
                     ctx,
                     &mut self.stats_panel,
                     &self.signal_history,
                     self.latest_spatial_force,
                 );
+            }
+            SerialMode::Finger3D => {
+                draw_stats_panel(
+                    ctx,
+                    &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_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);
+        // draw_matrix_config_panel(ctx, &mut self.matrix_config_panel, &mut self.matrix_config);
     }
 
     fn draw_panel_context_menu(&mut self, ctx: &egui::Context) {
@@ -415,15 +451,40 @@ impl EskinDesktopApp {
                     panel_restore_item(ui, "配置", &mut self.config_panel);
                     panel_restore_item(ui, "录制", &mut self.export_panel);
                     panel_restore_item(ui, "矩阵", &mut self.matrix_config_panel);
+                    if self.stats_panel.visible {
+                        if ui
+                            .add_sized(
+                                egui::vec2(ui.available_width(), 0.0),
+                                egui::Button::new("隐藏 统计"),
+                            )
+                            .clicked()
+                        {
+                            self.stats_panel.visible = false;
+                            close_menu = true;
+                        }
+                    } else {
                         panel_restore_item(ui, "统计", &mut self.stats_panel);
-                    if ui.button("打砖块").clicked() {
+                    }
+                    if ui
+                        .add_sized(
+                            egui::vec2(ui.available_width(), 0.0),
+                            egui::Button::new("打砖块"),
+                        )
+                        .clicked()
+                    {
                         self.breakout_visible = true;
                         close_menu = true;
                     }
 
                     ui.separator();
 
-                    if ui.button("全部显示").clicked() {
+                    if ui
+                        .add_sized(
+                            egui::vec2(ui.available_width(), 0.0),
+                            egui::Button::new("全部显示"),
+                        )
+                        .clicked()
+                    {
                         self.config_panel.visible = true;
                         self.export_panel.visible = true;
                         self.matrix_config_panel.visible = true;
@@ -447,6 +508,15 @@ 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();
@@ -456,6 +526,9 @@ impl EskinDesktopApp {
         self.force_estimator.reset();
         self.latest_spatial_force = None;
         self.signal_history.clear();
+        self.hand_signal_histories
+            .iter_mut()
+            .for_each(|history| history.clear());
 
         self.active_mode = match next {
             SerialMode::Finger => ActiveMode::Finger(FingerMode {
@@ -464,8 +537,34 @@ impl EskinDesktopApp {
                 range: 0..7000,
                 dot: true,
             }),
-            SerialMode::Hand => ActiveMode::Hand(HandGatewayMode { range: 0..7000 }),
+            SerialMode::Finger3D | SerialMode::Hand => {
+                ActiveMode::Hand(HandGatewayMode { range: 0..7000 })
             }
+        };
+    }
+}
+
+fn update_hand_signal_histories(
+    histories: &mut [Vec<f32>; HAND_FORCE_PANEL_COUNT],
+    raw_values: &[u32],
+) {
+    let mut offset = 0usize;
+    for (history, sample_count) in histories.iter_mut().zip(HAND_FORCE_SEGMENT_COUNTS) {
+        let raw_total = raw_values
+            .get(offset..offset + sample_count)
+            .unwrap_or(&[])
+            .iter()
+            .fold(0_u64, |sum, value| sum + *value as u64)
+            .min(u32::MAX as u64) as u32;
+        let force = raw_to_g1(raw_total).min(25.6);
+        let force = if force <= 0.1 { 0.0 } else { force };
+
+        history.push(force);
+        if history.len() > SUMMARY_POINTS_PER_SERIES {
+            history.remove(0);
+        }
+
+        offset += sample_count;
     }
 }
 
@@ -519,7 +618,7 @@ fn paint_split_viewport_shell(
     painter.rect_stroke(
         rect,
         egui::CornerRadius::same(8),
-        egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
         egui::StrokeKind::Outside,
     );
     painter.line_segment(
@@ -527,7 +626,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, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
     );
     painter.text(
         rect.left_top() + egui::vec2(14.0, 16.0),
@@ -589,14 +688,44 @@ 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.update_pressure_matrix();
         self.draw_workspace(ui);
         self.draw_title_bar(ui, frame);
-        self.draw_floating_panels(&ctx);
+        self.draw_floating_panels(&ctx, stats);
         self.draw_panel_context_menu(&ctx);
 
         // Keep repainting while the wgpu background is a realtime viewport.

src/breakout.rs

@@ -249,7 +249,11 @@ impl BreakoutGame {
     }
 
     fn launch_ball(&mut self) {
-        let direction = if self.level % 2 == 0 { -0.24 } else { 0.24 };
+        let direction = if self.level.is_multiple_of(2) {
+            -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;
     }
@@ -372,7 +376,7 @@ impl BreakoutGame {
         painter.rect_stroke(
             rect,
             egui::CornerRadius::same(6),
-            egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 110)),
+            egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.accent, 110)),
             egui::StrokeKind::Outside,
         );
 
@@ -469,7 +473,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, color_alpha(color, 92)))
+        .stroke(egui::Stroke::new(1.0_f32, color_alpha(color, 92)))
         .corner_radius(egui::CornerRadius::same(4))
         .inner_margin(egui::Margin::symmetric(8, 4))
         .show(ui, |ui| {
@@ -514,7 +518,7 @@ fn paint_arena_grid(painter: &egui::Painter, rect: egui::Rect) {
     painter.rect_stroke(
         rect,
         egui::CornerRadius::same(6),
-        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 70)),
+        egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.accent, 70)),
         egui::StrokeKind::Inside,
     );
 }
@@ -531,7 +535,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, color_alpha(ONE_DARK_PRO.accent_hot, alpha)),
+            egui::Stroke::new(1.4_f32, color_alpha(ONE_DARK_PRO.accent_hot, alpha)),
             egui::StrokeKind::Outside,
         );
     }
@@ -564,7 +568,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, color_alpha(ONE_DARK_PRO.border, 120)),
+        egui::Stroke::new(1.0_f32, color_alpha(ONE_DARK_PRO.border, 120)),
         egui::StrokeKind::Outside,
     );
     let center_x = meter.center().x;
@@ -573,7 +577,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, ONE_DARK_PRO.border_soft),
+        egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft),
     );
     let marker_x = center_x + control.axis.clamp(-1.0, 1.0) * meter.width() * 0.45;
     painter.circle_filled(

src/connection.rs

@@ -4,6 +4,7 @@ use std::time::Duration;
 
 use crossbeam_channel::{self, Receiver, Sender, TryRecvError};
 
+use crate::recording::Recorder;
 use crate::serial_core::serial::{
     SerialIoStats, SerialPortReadWrite, SerialProtocol, run_serial_loop,
 };
@@ -83,6 +84,7 @@ impl ConnectionManager {
         cols: u32,
         baud_rate: u32,
         protocol: SerialProtocol,
+        recorder: Recorder,
     ) {
         self.disconnect();
         self.set_state(ConnectionState::Connecting);
@@ -108,6 +110,7 @@ impl ConnectionManager {
                 &sample_tx,
                 &stats_tx,
                 &latest_sample,
+                recorder,
             );
             if let Err(e) = result {
                 eprintln!("[connection] device loop error: {e}");
@@ -176,6 +179,7 @@ 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,
@@ -187,9 +191,10 @@ fn run_device_loop(
     sample_tx: &Sender<Vec<i32>>,
     stats_tx: &Sender<SerialIoStats>,
     latest_sample: &Arc<Mutex<Option<PressureSample>>>,
+    recorder: Recorder,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let port = serialport::new(port_name, baud_rate)
-        .timeout(Duration::from_millis(100))
+        .timeout(Duration::from_millis(1))
         .open()?;
 
     *state.lock().unwrap() = ConnectionState::Connected;
@@ -205,6 +210,7 @@ fn run_device_loop(
         cancel_rx,
         sample_tx,
         Some(stats_tx),
+        Some(&recorder),
     );
 
     if let Ok(mut latest) = latest_sample.lock() {

src/main.rs

@@ -1,5 +1,5 @@
 #![allow(dead_code)]
-
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 mod app;
 mod breakout;
 mod connection;

src/matrix.rs

@@ -1,5 +1,31 @@
 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 let Some(ps) = r.pause_start.take() {
+        if r.state == RecordingState::Paused
+            && let Some(ps) = r.pause_start.take()
+        {
             r.paused_duration_ms += ps.elapsed().as_millis() as u64;
         }
-        }
         r.state = RecordingState::Idle;
         Ok(())
     }
@@ -317,16 +317,15 @@ impl Recorder {
         }
 
         // Set the start instant so duration_ms() reports the imported span
-        if !r.frames.is_empty() {
-            if let Some(last) = r.frames.last() {
+        if !r.frames.is_empty()
+            && 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,5 +1,8 @@
 use crate::{
-    matrix::{MatrixLayout, build_view_projection, glyph_world_position},
+    matrix::{
+        MatrixLayout, UNFOLDED_SENSOR_COUNT, build_view_projection, glyph_world_position,
+        unfolded_lh_sample_index,
+    },
     model::{AlphaMode, InstanceRaw, ModelVertex, Vertex},
     resources, texture,
 };
@@ -70,26 +73,96 @@ const HAND_TIP_MATRICES: [HandTipMatrix; 5] = [
     },
 ];
 
-const HAND_PALM_CHIPS: [HandPalmChip; 2] = [
+const UNFOLDED_CANVAS_SIZE: [f32; 2] = [850.0, 750.0];
+const UNFOLDED_CELL_SPACING_PX: f32 = 42.0;
+const UNFOLDED_SENSOR_CHIPS: [HandPalmChip; 10] = [
+    // Top cap: 2 rows x 4 columns.
     HandPalmChip {
-        center_px: [538.0, 608.0],
-        size_px: [248.0, 82.0],
-        angle_rad: 0.06,
-        rows: 5,
-        cols: 14,
+        center_px: [425.0, 165.0],
+        size_px: [176.0, 88.0],
+        angle_rad: 0.0,
+        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: [606.0, 780.0],
-        size_px: [72.0, 214.0],
-        angle_rad: 0.05,
+        center_px: [188.0, 534.0],
+        size_px: [46.0, 220.0],
+        angle_rad: 0.0,
+        rows: 5,
+        cols: 1,
+        sample_offset: 11,
+    },
+    HandPalmChip {
+        center_px: [236.0, 468.0],
+        size_px: [46.0, 352.0],
+        angle_rad: 0.0,
+        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.
@@ -100,14 +173,15 @@ struct HandTipMatrix {
     angle_rad: f32,
 }
 
-// Palm chips follow the hand layout: one horizontal 5x14 matrix and one vertical
-// 11x4 matrix, rendered as dark inset chip tiles on the palm.
+// One block in the flat 270-degree sensor layout. Coordinates use a dedicated
+// 850x750 canvas so the unfolded shape stays prominent across window sizes.
 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 {
@@ -156,7 +230,6 @@ 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,
@@ -168,8 +241,6 @@ 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,
@@ -277,10 +348,7 @@ impl BackgroundRenderResources {
             build_view_projection(1.0, &layout),
             surface_is_srgb,
             render_options,
-            [
-                hand_image_texture.width as f32,
-                hand_image_texture.height as f32,
-            ],
+            UNFOLDED_CANVAS_SIZE,
         );
         let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             label: Some("Pressure Matrix Uniform Buffer"),
@@ -497,8 +565,6 @@ 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);
 
@@ -551,23 +617,8 @@ impl BackgroundRenderResources {
                 contents: bytemuck::cast_slice(&hand_dot_instances),
                 usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             });
-        let hand_palm_chip_instances = build_hand_palm_chip_instances(
-            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_instances =
+            build_hand_palm_dot_instances(rows, cols, &[[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"),
@@ -589,7 +640,6 @@ 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,
@@ -600,8 +650,6 @@ 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,
@@ -623,10 +671,7 @@ impl BackgroundRenderResources {
             build_view_projection(aspect, &self.layout),
             self.surface_is_srgb,
             self.render_options,
-            [
-                self.hand_image_texture.width as f32,
-                self.hand_image_texture.height as f32,
-            ],
+            UNFOLDED_CANVAS_SIZE,
         );
         queue.write_buffer(
             &self.uniform_buffer,
@@ -653,8 +698,8 @@ impl BackgroundRenderResources {
             hand_pressure
         };
 
-        // Hand mode uses UV-anchored fingertip matrices over hand.png.
-        // Rebuild their instance positions here so pressure colors update every frame.
+        // Keep legacy fingertip buffers current while both hardware modes share
+        // the same renderer resources.
         self.hand_dot_instances = build_hand_dot_instances(
             self.rows,
             self.cols,
@@ -668,15 +713,9 @@ impl BackgroundRenderResources {
             bytemuck::cast_slice(&self.hand_dot_instances),
         );
 
-        // Palm chips reuse the same live 12x7 pressure frame, but draw it as
-        // embedded micro-pixels inside dark chip tiles.
-        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,
-        );
+        // Rebuild the 104-cell unfolded layout with the latest gateway samples.
+        self.hand_palm_dot_instances =
+            build_hand_palm_dot_instances(self.rows, self.cols, hand_pressure);
         queue.write_buffer(
             &self.hand_palm_dot_instance_buffer,
             0,
@@ -692,12 +731,7 @@ impl BackgroundRenderResources {
 
         match active_mode {
             ActiveMode::Finger(mode) => self.paint_finger(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);
-            }
+            ActiveMode::Hand(mode) => self.paint_hand(render_pass, mode),
         }
     }
 
@@ -719,22 +753,7 @@ impl BackgroundRenderResources {
     fn paint_hand(&self, render_pass: &mut wgpu::RenderPass<'_>, mode: &HandGatewayMode) {
         let _range = mode.range.clone();
 
-        // 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);
-
+        // Match Finger mode: draw only the 104 independent pressure dots.
         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(..));
@@ -1072,39 +1091,6 @@ 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,
@@ -1156,28 +1142,6 @@ 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,
@@ -1225,44 +1189,26 @@ 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 = HAND_PALM_CHIPS
+    let chip_dot_count: usize = UNFOLDED_SENSOR_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 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 (chip_index, chip) in UNFOLDED_SENSOR_CHIPS.iter().enumerate() {
         for row in 0..chip.rows {
             for col in 0..chip.cols {
-                let index = (row * chip.cols + col) as usize;
-                let offset = match chip_index {
-                    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;
+                let index = unfolded_adc_sample_index(chip_index, row, col);
+                let [normalized, display_value] = sample_pressure_at(pressure, index, index);
+                let [x, y] = unfolded_cell_position(&chip, row, col);
 
                 instances.push(GlyphInstance {
                     world_position: [
-                        x / image_width.max(1.0),
-                        y / image_height.max(1.0),
+                        x / UNFOLDED_CANVAS_SIZE[0],
+                        y / UNFOLDED_CANVAS_SIZE[1],
                         0.0,
                         1.0,
                     ],
@@ -1275,6 +1221,47 @@ 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)
@@ -1283,6 +1270,225 @@ 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,6 +457,7 @@ fn create_color_material(
     ))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn create_material(
     device: &wgpu::Device,
     texture_bind_group_layout: &wgpu::BindGroupLayout,
@@ -702,6 +703,7 @@ fn append_gltf_node_meshes(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 fn append_gltf_primitive_mesh(
     mesh_name: &str,
     primitive_index: usize,
@@ -969,7 +971,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() % pixel_width != 0 {
+    if pixel_width == 0 || !pixels.len().is_multiple_of(pixel_width) {
         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() % 2 != 0 {
+        if !data.len().is_multiple_of(2) {
             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() % 2 != 0 {
+        if !data.len().is_multiple_of(2) {
             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,3 +188,61 @@ 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 % 2 == 0 {
+        if n.is_multiple_of(2) {
             (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0
         } else {
             sorted[n / 2]

src/serial_core/serial.rs

@@ -1,3 +1,4 @@
+use crate::recording::Recorder;
 use crate::serial_core::codec::Codec;
 use crate::serial_core::codecs::hand_gateway::{HandGatewayCodec, HandGatewayFrame};
 use crate::serial_core::codecs::tactile_a::TactileACodec;
@@ -6,7 +7,7 @@ use crossbeam_channel::{Receiver, Sender};
 use std::io::{Read, Write};
 use std::time::{Duration, Instant};
 
-const POLL_INTERVAL_MS: u64 = 10;
+const POLL_INTERVAL_MS: u64 = 5;
 const DEFAULT_HAND_GATEWAY_NODE_SAMPLE_COUNTS: &[u16] = &[84, 84, 84, 84, 84, 70, 44];
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
@@ -23,6 +24,7 @@ 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,
@@ -31,12 +33,15 @@ pub fn run_serial_loop(
     cancel_rx: &Receiver<()>,
     sample_tx: &Sender<Vec<i32>>,
     stats_tx: Option<&Sender<SerialIoStats>>,
+    recorder: Option<&Recorder>,
 ) {
     match protocol {
         SerialProtocol::TactileA => {
-            run_tactile_a_loop(port, rows, cols, cancel_rx, sample_tx, stats_tx)
+            run_tactile_a_loop(port, rows, cols, cancel_rx, sample_tx, stats_tx, recorder)
+        }
+        SerialProtocol::HandGateway => {
+            run_hand_gateway_loop(port, cancel_rx, sample_tx, stats_tx, recorder)
         }
-        SerialProtocol::HandGateway => run_hand_gateway_loop(port, cancel_rx, sample_tx, stats_tx),
     }
 }
 
@@ -47,6 +52,7 @@ fn run_tactile_a_loop(
     cancel_rx: &Receiver<()>,
     sample_tx: &Sender<Vec<i32>>,
     stats_tx: Option<&Sender<SerialIoStats>>,
+    recorder: Option<&Recorder>,
 ) {
     let session_started_at = Instant::now();
     let mut codec = TactileACodec::new(cols, rows);
@@ -68,12 +74,12 @@ fn run_tactile_a_loop(
         }
 
         // Send poll request
-        if let Ok(req_bytes) = codec.encode(&req_frame) {
-            if port.write_all(&req_bytes).is_ok() {
+        if let Ok(req_bytes) = codec.encode(&req_frame)
+            && 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;
@@ -88,10 +94,15 @@ 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 Ok(vals) = TactileACodec::parse_data_frame(&rep.payload) {
-                                    let _ = sample_tx.try_send(vals);
+                            if let TactileAFrame::Rep(rep) = frame
+                                && 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);
                             }
                         }
                     }
@@ -116,6 +127,7 @@ fn run_hand_gateway_loop(
     cancel_rx: &Receiver<()>,
     sample_tx: &Sender<Vec<i32>>,
     stats_tx: Option<&Sender<SerialIoStats>>,
+    recorder: Option<&Recorder>,
 ) {
     let session_started_at = Instant::now();
     let mut codec = HandGatewayCodec::new(DEFAULT_HAND_GATEWAY_NODE_SAMPLE_COUNTS);
@@ -174,6 +186,11 @@ fn run_hand_gateway_loop(
 
                             if parse_ok {
                                 // println!("[hand-packet-values] samples={}", vals.len());
+                                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);
                             }
                         }

src/style.rs

@@ -1,4 +1,4 @@
-use eframe::egui;
+use eframe::egui::{self, Color32};
 
 #[derive(Clone, Copy)]
 pub struct AppTheme {
@@ -29,7 +29,7 @@ pub struct DesignMetrics {
 }
 
 pub const ONE_DARK_PRO: AppTheme = AppTheme {
-    bg: egui::Color32::from_rgb(30, 40, 50),
+    bg: egui::Color32::BLACK,
     panel: egui::Color32::from_rgb(22, 28, 35),
     panel_strong: egui::Color32::from_rgb(34, 43, 54),
     panel_deep: egui::Color32::from_rgb(15, 20, 27),
@@ -61,6 +61,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 CENTER_PANEL_TOP: f32 = 48.0;
     pub const LEFT_X: f32 = 24.0;
     pub const RIGHT_X: f32 = 1328.0;
@@ -76,7 +77,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, theme.border);
+    visuals.window_stroke = egui::Stroke::new(1.0_f32, theme.border);
     visuals.extreme_bg_color = theme.panel_deep;
     visuals.faint_bg_color = theme.panel_strong;
     visuals.code_bg_color = theme.panel_deep;
@@ -84,23 +85,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, theme.border_soft);
-    visuals.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0, theme.text);
+    visuals.widgets.noninteractive.bg_stroke = egui::Stroke::new(1.0_f32, theme.border_soft);
+    visuals.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
     visuals.widgets.inactive.bg_fill = theme.panel_strong;
-    visuals.widgets.inactive.bg_stroke = egui::Stroke::new(1.0, theme.border_soft);
-    visuals.widgets.inactive.fg_stroke = egui::Stroke::new(1.0, theme.text);
+    visuals.widgets.inactive.bg_stroke = egui::Stroke::new(1.0_f32, theme.border_soft);
+    visuals.widgets.inactive.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
     visuals.widgets.hovered.bg_fill = egui::Color32::from_rgb(44, 57, 70);
-    visuals.widgets.hovered.bg_stroke = egui::Stroke::new(1.0, theme.accent);
-    visuals.widgets.hovered.fg_stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
+    visuals.widgets.hovered.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent);
+    visuals.widgets.hovered.fg_stroke = egui::Stroke::new(1.0_f32, egui::Color32::WHITE);
     visuals.widgets.active.bg_fill = theme.accent;
-    visuals.widgets.active.bg_stroke = egui::Stroke::new(1.0, theme.accent_hot);
-    visuals.widgets.active.fg_stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
+    visuals.widgets.active.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent_hot);
+    visuals.widgets.active.fg_stroke = egui::Stroke::new(1.0_f32, 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, theme.accent);
-    visuals.widgets.open.fg_stroke = egui::Stroke::new(1.0, theme.text);
+    visuals.widgets.open.bg_stroke = egui::Stroke::new(1.0_f32, theme.accent);
+    visuals.widgets.open.fg_stroke = egui::Stroke::new(1.0_f32, theme.text);
 
     visuals.selection.bg_fill = egui::Color32::from_rgb(35, 123, 140);
-    visuals.selection.stroke = egui::Stroke::new(1.0, egui::Color32::WHITE);
+    visuals.selection.stroke = egui::Stroke::new(1.0_f32, egui::Color32::WHITE);
     visuals.hyperlink_color = theme.accent_hot;
     ctx.set_visuals(visuals);
 
@@ -126,8 +127,8 @@ 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(),
+        "MapleMono-NF-CN-Bold".to_owned(),
+        egui::FontData::from_static(include_bytes!("../static/MapleMono-NF-CN-Bold.ttf")).into(),
     );
 
     let has_yahei = std::fs::read(r"C:\Windows\Fonts\msyh.ttc")
@@ -144,7 +145,7 @@ pub fn apply_fonts(ctx: &egui::Context) {
         .families
         .entry(egui::FontFamily::Proportional)
         .or_default()
-        .insert(0, "Hack-Bold".to_owned());
+        .insert(0, "MapleMono-NF-CN-Bold".to_owned());
     if has_yahei {
         fonts
             .families
@@ -157,7 +158,7 @@ pub fn apply_fonts(ctx: &egui::Context) {
         .families
         .entry(egui::FontFamily::Monospace)
         .or_default()
-        .insert(0, "Hack-Bold".to_owned());
+        .insert(0, "MapleMono-NF-CN-Bold".to_owned());
     if has_yahei {
         fonts
             .families
@@ -173,7 +174,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, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0_f32, 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 {
@@ -197,7 +198,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, ONE_DARK_PRO.border_soft))
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border_soft))
         .corner_radius(egui::CornerRadius::same(4))
         .inner_margin(egui::Margin::symmetric(
             METRICS.group_padding_x,
@@ -208,7 +209,20 @@ 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, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
+        .corner_radius(egui::CornerRadius::same(4))
+        .min_size(egui::vec2(0.0, METRICS.button_height))
+}
+
+pub fn rich_tag_button(
+    label: impl Into<String>,
+    color: impl Into<Color32>,
+) -> egui::Button<'static> {
+    let text = egui::RichText::new(label.into()).color(color);
+
+    egui::Button::new(text)
+        .fill(ONE_DARK_PRO.panel_strong)
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(0.0, METRICS.button_height))
 }
@@ -216,7 +230,7 @@ pub fn tag_button(label: impl Into<egui::WidgetText>) -> egui::Button<'static> {
 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, ONE_DARK_PRO.accent_hot))
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.accent_hot))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(112.0, METRICS.button_height))
 }
@@ -225,7 +239,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,
+            1.0_f32,
             egui::Color32::from_rgb(255, 138, 126),
         ))
         .corner_radius(egui::CornerRadius::same(4))
@@ -238,7 +252,7 @@ pub fn accent_button(
 ) -> egui::Button<'static> {
     egui::Button::new(label)
         .fill(fill)
-        .stroke(egui::Stroke::new(1.0, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(0.0, METRICS.button_height))
 }
@@ -257,7 +271,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, stroke))
+        .stroke(egui::Stroke::new(1.0_f32, stroke))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(egui::vec2(96.0, METRICS.button_height))
 }
@@ -265,7 +279,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, ONE_DARK_PRO.border))
+        .stroke(egui::Stroke::new(1.0_f32, ONE_DARK_PRO.border))
         .corner_radius(egui::CornerRadius::same(4))
         .min_size(size)
 }

src/texture.rs

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

src/theme.rs

@@ -83,53 +83,6 @@ 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/utils.rs

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

static/wgsl/shader.wgsl

@@ -126,15 +126,7 @@ fn vs_background(@builtin(vertex_index) vertex_index: u32) -> BackgroundVertexOu
 
 @fragment
 fn fs_background(@builtin(position) frag_coord: vec4f) -> @location(0) vec4f {
-    let pixel = frag_coord.xy;
-    let viewport = u.viewport.xy;
-    let uv = pixel / max(viewport, vec2f(1.0, 1.0));
-    var color = mix(vec3f(0.018, 0.019, 0.022), vec3f(0.038, 0.040, 0.046), 1.0 - uv.y);
-    let vignette = smoothstep(0.18, 0.92, length((uv - vec2f(0.52, 0.48)) * vec2f(viewport.x / viewport.y, 1.0)));
-    color *= 1.0 - vignette * 0.22;
-    color += vec3f(0.010, 0.010, 0.012) * (1.0 - smoothstep(0.0, 0.85, abs(uv.y - 0.50)));
-
-    return output_color(color, 1.0);
+    return output_color(vec3f(0.0, 0.0, 0.0), 1.0);
 }
 
 
@@ -357,10 +349,8 @@ fn circle_alpha(local: vec2f, radius: f32, softness: f32) -> f32 {
     return 1.0 - smoothstep(radius, radius + softness, dist);
 }
 
-// Convert a point authored in hand.png UV space into clip space.
-// 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 {
+// Convert a point authored in sensor-canvas UV space into aspect-fitted clip space.
+fn sensor_canvas_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);
 
@@ -428,7 +418,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(hand_image_uv_to_clip(image_uv), 0.0, 1.0);
+    out.clip_position = vec4f(sensor_canvas_uv_to_clip(image_uv), 0.0, 1.0);
     out.local = vertex.local;
     return out;
 }
@@ -478,7 +468,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 = hand_image_uv_to_clip(instance.world_position.xy);
+    let center = sensor_canvas_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);
@@ -508,75 +498,14 @@ 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);
 
-    // Palm chip pixels are deliberately smaller than fingertip beads so they read as a chip matrix.
-    let center = hand_image_uv_to_clip(instance.world_position.xy);
-    let pixel_size = u.glyph.x * mix(0.13, 0.25, shaped);
+    // Use the same on-screen point size as Finger mode.
+    let center = sensor_canvas_uv_to_clip(instance.world_position.xy);
+    let pixel_size = u.glyph.x * mix(1.07, 2.23, shaped);
     let ndc_offset = vertex.local * vec2f(pixel_size / u.viewport.x, pixel_size / u.viewport.y) * 2.0;
 
     var out: DotVertexOutput;
@@ -589,16 +518,11 @@ 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 pixel = chip_pixel_alpha(in.local, 0.52, 0.070);
-    let glow = circle_alpha(in.local, 0.95, 0.22) * intensity * 0.36;
+    let base_color = sample_range_color(intensity);
 
-    let cold = vec3f(0.070, 0.340, 0.360);
-    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 = circle_alpha(in.local, 0.46, 0.045);
+    let color = base_color * mix(0.86, 1.06, intensity);
 
-    let alpha = max(pixel * (0.20 + intensity * 0.76), glow);
     return output_color(color, alpha);
 }
 

wix/main.wxs

@@ -0,0 +1,254 @@
+<?xml version='1.0' encoding='windows-1252'?>
+<!--
+  Copyright (C) 2017 Christopher R. Field.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<!--
+  The "cargo wix" subcommand provides a variety of predefined variables available
+  for customization of this template. The values for each variable are set at
+  installer creation time. The following variables are available:
+
+  TargetTriple      = The rustc target triple name.
+  TargetEnv         = The rustc target environment. This is typically either
+                      "msvc" or "gnu" depending on the toolchain downloaded and
+                      installed.
+  TargetVendor      = The rustc target vendor. This is typically "pc", but Rust
+                      does support other vendors, like "uwp".
+  CargoTargetBinDir = The complete path to the directory containing the
+                      binaries (exes) to include. The default would be
+                      "target\release\". If an explicit rustc target triple is
+                      used, i.e. cross-compiling, then the default path would
+                      be "target\<CARGO_TARGET>\<CARGO_PROFILE>",
+                      where "<CARGO_TARGET>" is replaced with the "CargoTarget"
+                      variable value and "<CARGO_PROFILE>" is replaced with the
+                      value from the "CargoProfile" variable. This can also
+                      be overridden manually with the "target-bin-dir" flag.
+  CargoTargetDir    = The path to the directory for the build artifacts, i.e.
+                      "target".
+  CargoProfile      = The cargo profile used to build the binaries
+                      (usually "debug" or "release").
+  Version           = The version for the installer. The default is the
+                      "Major.Minor.Fix" semantic versioning number of the Rust
+                      package.
+-->
+
+<!--
+  Please do not remove these pre-processor If-Else blocks. These are used with
+  the `cargo wix` subcommand to automatically determine the installation
+  destination for 32-bit versus 64-bit installers. Removal of these lines will
+  cause installation errors.
+-->
+<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
+    <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
+<?else ?>
+    <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
+<?endif ?>
+
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
+
+    <Product
+        Id='*'
+        Name='eskin-model-player'
+        UpgradeCode='7CEF316B-BE23-4533-B4B2-87D06D2230B5'
+        Manufacturer='JOYSONQUIN'
+        Language='1033'
+        Codepage='1252'
+        Version='$(var.Version)'>
+
+        <Package Id='*'
+            Keywords='Installer'
+            Description='Desktop pressure sensor visualization and playback application.'
+            Manufacturer='JOYSONQUIN'
+            InstallerVersion='450'
+            Languages='1033'
+            Compressed='yes'
+            InstallScope='perUser'
+            InstallPrivileges='limited'
+            SummaryCodepage='1252'
+            />
+
+        <MajorUpgrade
+            Schedule='afterInstallInitialize'
+            DowngradeErrorMessage='A newer version of [ProductName] is already installed. Setup will now exit.'/>
+
+        <Media Id='1' Cabinet='media1.cab' EmbedCab='yes' DiskPrompt='CD-ROM #1'/>
+        <Property Id='DiskPrompt' Value='eskin-model-player Installation'/>
+
+        <Directory Id='TARGETDIR' Name='SourceDir'>
+            <Directory Id='LocalAppDataFolder'>
+                <Directory Id='APPLICATIONFOLDER' Name='eskin-model-player'>
+                    
+                    <!--
+                      Enabling the license sidecar file in the installer is a four step process:
+
+                      1. Uncomment the `Component` tag and its contents.
+                      2. Change the value for the `Source` attribute in the `File` tag to a path
+                         to the file that should be included as the license sidecar file. The path
+                         can, and probably should be, relative to this file.
+                      3. Change the value for the `Name` attribute in the `File` tag to the
+                         desired name for the file when it is installed alongside the `bin` folder
+                         in the installation directory. This can be omitted if the desired name is
+                         the same as the file name.
+                      4. Uncomment the `ComponentRef` tag with the Id attribute value of "License"
+                         further down in this file.
+                    -->
+                    <!--
+                    <Component Id='License' Guid='*'>
+                        <File Id='LicenseFile' Name='ChangeMe' DiskId='1' Source='C:\Path\To\File' KeyPath='yes'/>
+                    </Component>
+                    -->
+
+                    <Directory Id='Bin' Name='bin'>
+                        <Component Id='Path' Guid='FD230ABD-75B9-47D4-870B-CF2EA72B76BE'>
+                            <RegistryValue
+                                Root='HKCU'
+                                Key='Software\JOYSONQUIN\eskin-model-player'
+                                Name='PathComponent'
+                                Type='integer'
+                                Value='1'
+                                KeyPath='yes'/>
+                            <RemoveFolder Id='RemoveBinFolder' Directory='Bin' On='uninstall'/>
+                            <RemoveFolder Id='RemoveApplicationFolder' Directory='APPLICATIONFOLDER' On='uninstall'/>
+                            <Environment
+                                Id='PATH'
+                                Name='PATH'
+                                Value='[Bin]'
+                                Permanent='no'
+                                Part='last'
+                                Action='set'
+                                System='no'/>
+                        </Component>
+                        <Component Id='binary0' Guid='302CAFB5-6951-426B-BC5A-988C351A2CF2'>
+                            <RegistryValue
+                                Root='HKCU'
+                                Key='Software\JOYSONQUIN\eskin-model-player'
+                                Name='BinaryComponent'
+                                Type='integer'
+                                Value='1'
+                                KeyPath='yes'/>
+                            <File
+                                Id='exe0'
+                                Name='ESkinPlayer.exe'
+                                DiskId='1'
+                                Source='$(var.CargoTargetBinDir)\ESkinPlayer.exe'/>
+                        </Component>
+                    </Directory>
+                </Directory>
+            </Directory>
+        </Directory>
+
+        <Feature
+            Id='Binaries'
+            Title='Application'
+            Description='Installs all binaries and the license.'
+            Level='1'
+            ConfigurableDirectory='APPLICATIONFOLDER'
+            AllowAdvertise='no'
+            Display='expand'
+            Absent='disallow'>
+            
+            <!--
+              Uncomment the following `ComponentRef` tag to add the license
+              sidecar file to the installer.
+            -->
+            <!--<ComponentRef Id='License'/>-->
+
+            <ComponentRef Id='binary0'/>
+
+            <Feature
+                Id='Environment'
+                Title='PATH Environment Variable'
+                Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.'
+                Level='1'
+                Absent='allow'>
+                <ComponentRef Id='Path'/>
+            </Feature>
+        </Feature>
+
+        <SetProperty Id='ARPINSTALLLOCATION' Value='[APPLICATIONFOLDER]' After='CostFinalize'/>
+
+        
+        <!--
+          Uncomment the following `Icon` and `Property` tags to change the product icon.
+
+          The product icon is the graphic that appears in the Add/Remove
+          Programs control panel for the application.
+        -->
+        <!--<Icon Id='ProductICO' SourceFile='wix\Product.ico'/>-->
+        <!--<Property Id='ARPPRODUCTICON' Value='ProductICO' />-->
+
+        
+        <!--
+          Adding a URL to Add/Remove Programs control panel listing for the
+          application is a two step process:
+
+          1. Uncomment the following `Property` tag with the "ARPHELPLINK" Id
+             attribute value.
+          2. Change the value for `Value` attribute of the following
+             `Property` tag to a valid URL.
+        -->
+        <!--<Property Id='ARPHELPLINK' Value='ChangeMe'/>-->
+
+        <UI>
+            <UIRef Id='WixUI_FeatureTree'/>
+            
+            <!--
+              Enabling the EULA dialog in the installer is a three step process:
+
+                1. Comment out or remove the two `Publish` tags that follow the
+                   `WixVariable` tag.
+                2. Uncomment the `<WixVariable Id='WixUILicenseRtf' Value='Path\to\Eula.rft'>` tag further down
+                3. Replace the `Value` attribute of the `WixVariable` tag with
+                   the path to a RTF file that will be used as the EULA and
+                   displayed in the license agreement dialog.
+            -->
+            <Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>
+            <Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>
+
+        </UI>
+
+        
+        <!--
+          Enabling the EULA dialog in the installer requires uncommenting
+          the following `WixUILicenseRTF` tag and changing the `Value`
+          attribute.
+        -->
+        <!-- <WixVariable Id='WixUILicenseRtf' Value='Relative\Path\to\Eula.rtf'/> -->
+
+        
+        <!--
+          Uncomment the next `WixVariable` tag to customize the installer's
+          Graphical User Interface (GUI) and add a custom banner image across
+          the top of each screen. See the WiX Toolset documentation for details
+          about customization.
+
+          The banner BMP dimensions are 493 x 58 pixels.
+        -->
+        <!--<WixVariable Id='WixUIBannerBmp' Value='wix\Banner.bmp'/>-->
+
+        
+        <!--
+          Uncomment the next `WixVariable` tag to customize the installer's
+          Graphical User Interface (GUI) and add a custom image to the first
+          dialog, or screen. See the WiX Toolset documentation for details about
+          customization.
+
+          The dialog BMP dimensions are 493 x 312 pixels.
+        -->
+        <!--<WixVariable Id='WixUIDialogBmp' Value='wix\Dialog.bmp'/>-->
+
+    </Product>
+
+</Wix>