From 4d0e65c02b73eec0bbc52f4db8fff2a49eafb2b5 Mon Sep 17 00:00:00 2001 From: lenn Date: Fri, 17 Jul 2026 13:55:22 +0800 Subject: [PATCH] toml config support --- Cargo.lock | 10 +- Cargo.toml | 2 + config.toml | 59 ++++++++++++ src/app.rs | 256 ++++++++++++++++++++++---------------------------- src/config.rs | 70 ++++++++++++++ src/main.rs | 1 + 6 files changed, 251 insertions(+), 147 deletions(-) create mode 100644 config.toml create mode 100644 src/config.rs diff --git a/Cargo.lock b/Cargo.lock index 0cdee20..aac7816 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1318,8 +1318,10 @@ dependencies = [ "gltf", "image", "log", + "serde", "serialport", "tobj", + "toml", "winresource", ] @@ -4001,9 +4003,9 @@ dependencies = [ [[package]] name = "toml" -version = "1.1.2+spec-1.1.0" +version = "1.1.3+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee" +checksum = "53c96ecdfa941c8fc4fcaed14f99ada8ebed502eef533015095a07e3301d4c3c" dependencies = [ "indexmap", "serde_core", @@ -4046,9 +4048,9 @@ dependencies = [ [[package]] name = "toml_writer" -version = "1.1.1+spec-1.1.0" +version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db" +checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2" [[package]] name = "tracing" diff --git a/Cargo.toml b/Cargo.toml index 9f9ee7a..1e58660 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,8 @@ crc = "3.4.0" log = "0.4.29" tobj = "4.0.4" gltf = "1.4.1" +toml = "1.1.3" +serde = { version = "1.0.228", features = ["derive"] } [build-dependencies] diff --git a/config.toml b/config.toml new file mode 100644 index 0000000..c42f1be --- /dev/null +++ b/config.toml @@ -0,0 +1,59 @@ +[thumb] +"0.57" = 35694 +"2.57" = 226640 +"3.57" = 319868 +"4.57" = 398021 +"5.57" = 450448 +"6.57" = 510506 +"8.57" = 592075 +"10.57" = 655760 +"15.57" = 771671 +"20.57" = 813967 + +[index] +"0.57" = 45490 +"2.57" = 267579 +"3.57" = 352066 +"4.57" = 431681 +"5.57" = 457605 +"6.57" = 550875 +"8.57" = 624327 +"10.57" = 732735 +"15.57" = 883397 +"20.57" = 899338 + +[middle] +"0.57" = 51562 +"2.57" = 252840 +"3.57" = 326531 +"4.57" = 386571 +"5.57" = 415819 +"6.57" = 514679 +"8.57" = 631745 +"10.57" = 678945 +"15.57" = 810847 +"20.57" = 900422 + +[ring] +"0.57" = 33213 +"2.57" = 220611 +"3.57" = 307383 +"4.57" = 369637 +"5.57" = 430462 +"6.57" = 489659 +"8.57" = 584789 +"10.57" = 664960 +"15.57" = 802749 +"20.57" = 926907 + +[little] +"0.57" = 44291 +"2.57" = 216657 +"3.57" = 301950 +"4.57" = 366186 +"5.57" = 384791 +"6.57" = 496521 +"8.57" = 566189 +"10.57" = 701459 +"15.57" = 845608 +"20.57" = 940796 diff --git a/src/app.rs b/src/app.rs index 27affbe..dd5c30a 100644 --- a/src/app.rs +++ b/src/app.rs @@ -1,4 +1,5 @@ use crate::breakout::{BreakoutGame, control_from_matrix}; +use crate::config::{HandForceConfig, try_load_hand_force_config}; use crate::connection::{ConnectionManager, ConnectionState}; use crate::force::{ForceEstimatorState, HAND_FINGERTIP_COUNT, HudSpatialForce}; use crate::recording::Recorder; @@ -17,6 +18,7 @@ use crate::{ }, }; use eframe::{egui, egui_wgpu}; +use std::collections::BTreeMap; use std::{ sync::Arc, time::{Duration, Instant}, @@ -70,6 +72,7 @@ pub struct EskinDesktopApp { context_menu_open: bool, context_menu_pos: egui::Pos2, active_mode: ActiveMode, + hand_force_config: Option, } struct LiveRateMeters { @@ -137,6 +140,7 @@ impl EskinDesktopApp { MATRIX_COLS, )); + let hand_force_config = try_load_hand_force_config(); Self { connect_panel: FloatingPanelState::new([0.0, 0.0], [layout::RIGHT_TAG_X, 48.0]), connect_state: ConnectPanelState::default(), @@ -184,6 +188,7 @@ impl EskinDesktopApp { context_menu_open: false, context_menu_pos: egui::pos2(24.0, 48.0), active_mode: ActiveMode::Hand(HandGatewayMode { range: 0..7000 }), + hand_force_config, } } @@ -248,7 +253,8 @@ impl EskinDesktopApp { fn analyze_spatial_force(&mut self, values: &[u32]) { if matches!(self.config_state.mode, SerialMode::Hand) { let enabled = std::array::from_fn(|tip_index| { - hand_segment_force(values, tip_index) > HAND_FORCE_DISPLAY_THRESHOLD_N + hand_segment_force(values, tip_index, self.hand_force_config.as_ref()) + > HAND_FORCE_DISPLAY_THRESHOLD_N }); self.latest_hand_spatial_forces = self .force_estimator @@ -351,9 +357,12 @@ impl EskinDesktopApp { self.analyze_spatial_force(&sample.matrix); - let force = - update_hand_signal_histories(&mut self.hand_signal_histories, &sample.matrix) - .min(25.6); + let force = update_hand_signal_histories( + &mut self.hand_signal_histories, + &sample.matrix, + self.hand_force_config.as_ref(), + ) + .min(25.6); self.signal_history.push(force); if self.signal_history.len() > SUMMARY_POINTS_PER_SERIES { self.signal_history.remove(0); @@ -712,10 +721,11 @@ fn paint_spatial_force_arrow( fn update_hand_signal_histories( histories: &mut [Vec; HAND_FORCE_PANEL_COUNT], raw_values: &[u32], + config: Option<&HandForceConfig>, ) -> f32 { let mut total_force = 0.0; for (index, history) in histories.iter_mut().enumerate() { - let force = hand_segment_force(raw_values, index); + let force = hand_segment_force(raw_values, index, config); let force = if force <= HAND_FORCE_DISPLAY_THRESHOLD_N { 0.0 } else { @@ -731,7 +741,7 @@ fn update_hand_signal_histories( total_force } -fn hand_segment_force(raw_values: &[u32], index: usize) -> f32 { +fn hand_segment_force(raw_values: &[u32], index: usize, config: Option<&HandForceConfig>) -> f32 { let offset: usize = HAND_FORCE_SEGMENT_COUNTS[..index.min(HAND_FORCE_PANEL_COUNT)] .iter() .sum(); @@ -746,22 +756,78 @@ fn hand_segment_force(raw_values: &[u32], index: usize) -> f32 { .fold(0_u64, |sum, value| sum + *value as u64) .min(u32::MAX as u64) as u32; - raw_to_hand_segment_g(index, raw_total).min(20.6) + raw_to_hand_segment_g(index, raw_total, config).min(20.6) } -fn raw_to_hand_segment_g(index: usize, raw: u32) -> f32 { +fn raw_to_hand_segment_g(index: usize, raw: u32, config: Option<&HandForceConfig>) -> f32 { match index { - 0 => raw_to_g1(raw), - 1 => raw_to_g2(raw), - 2 => raw_to_g3(raw), - 3 => raw_to_g4(raw), - 4 => raw_to_g5(raw), + 0 => raw_to_g1(raw, config), + 1 => raw_to_g2(raw, config), + 2 => raw_to_g3(raw, config), + 3 => raw_to_g4(raw, config), + 4 => raw_to_g5(raw, config), 5 => raw_to_g6(raw), 6 => raw_to_g7(raw), _ => raw_to_gd(raw), } } +fn to_force_table(values: &BTreeMap) -> Vec<(u32, f32)> { + let mut table = values + .iter() + .filter_map(|(force_n, raw)| force_n.parse::().ok().map(|force| (*raw, force))) + .collect::>(); + table.sort_by(|a, b| a.1.total_cmp(&b.1)); + table.insert(0, (0, 0.0)); + table +} + +fn interpolate_force(raw: u32, table: &[(u32, f32)]) -> f32 { + let Some(&(first_raw, first_force)) = table.first() else { + return 0.0; + }; + let Some(&(last_raw, last_force)) = table.last() else { + return 0.0; + }; + + if raw <= first_raw { + return first_force; + } + if raw >= last_raw { + return last_force; + } + + let right = table.partition_point(|(raw_point, _)| *raw_point <= raw); + let (raw_left, force_left) = table[right - 1]; + let (raw_right, force_right) = table[right]; + let ratio = (raw - raw_left) as f32 / (raw_right - raw_left).max(1) as f32; + force_left + ratio * (force_right - force_left) +} + +fn force_from_config_or_fallback( + raw: u32, + config_values: Option<&BTreeMap>, + fallback_raw: &[u32], + fallback_force_centi_n: &[f32], +) -> f32 { + if let Some(config_values) = config_values { + let table = to_force_table(config_values); + if table.len() >= 2 && table.windows(2).all(|pair| pair[0].0 <= pair[1].0) { + return interpolate_force(raw, &table); + } + log::warn!( + "Hand force config raw values are not monotonically increasing; using fallback table" + ); + } + + let fallback = fallback_raw + .iter() + .copied() + .zip(fallback_force_centi_n.iter().map(|force| force / 100.0)) + .collect::>(); + interpolate_force(raw, &fallback) +} + fn raw_to_gd(raw: u32) -> f32 { const RAW: [u32; 11] = [ 0, 486, 5310, 8130, 10005, 12883, 14700, 18141, 19877, 26270, 32648, @@ -797,7 +863,7 @@ fn raw_to_gd(raw: u32) -> f32 { (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 } -fn raw_to_g1(raw: u32) -> f32 { +fn raw_to_g1(raw: u32, config: Option<&HandForceConfig>) -> f32 { const RAW: [u32; 11] = [ 0, 35694, 226640, 319868, 398021, 450448, 510506, 592075, 655760, 771671, 813967, ]; @@ -805,34 +871,10 @@ fn raw_to_g1(raw: u32) -> f32 { 0.0, 57.0, 257.0, 357.0, 457.0, 557.0, 657.0, 857.0, 1057.0, 1557.0, 2057.0, ]; - if raw <= RAW[0] { - return FORCE_CENTI_N[0] / 100.0; - } - - if raw >= RAW[RAW.len() - 1] { - return FORCE_CENTI_N[FORCE_CENTI_N.len() - 1] / 100.0; - } - - let mut left = 0usize; - let mut right = RAW.len() - 1; - while left + 1 < right { - let mid = (left + right) / 2; - if RAW[mid] <= raw { - left = mid; - } else { - right = mid; - } - } - - let raw_left = RAW[left] as f32; - let raw_right = RAW[right] as f32; - let span = (raw_right - raw_left).max(1.0); - let ratio = (raw as f32 - raw_left) / span; - - (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 + force_from_config_or_fallback(raw, config.map(|cfg| &cfg.thumb), &RAW, &FORCE_CENTI_N) } -fn raw_to_g2(raw: u32) -> f32 { +fn raw_to_g2(raw: u32, config: Option<&HandForceConfig>) -> f32 { const RAW: [u32; 11] = [ 0, 45490, 267579, 352066, 431681, 457605, 550875, 624327, 732735, 883397, 899338, ]; @@ -840,34 +882,10 @@ fn raw_to_g2(raw: u32) -> f32 { 0.0, 57.0, 257.0, 357.0, 457.0, 557.0, 657.0, 857.0, 1057.0, 1557.0, 2057.0, ]; - if raw <= RAW[0] { - return FORCE_CENTI_N[0] / 100.0; - } - - if raw >= RAW[RAW.len() - 1] { - return FORCE_CENTI_N[FORCE_CENTI_N.len() - 1] / 100.0; - } - - let mut left = 0usize; - let mut right = RAW.len() - 1; - while left + 1 < right { - let mid = (left + right) / 2; - if RAW[mid] <= raw { - left = mid; - } else { - right = mid; - } - } - - let raw_left = RAW[left] as f32; - let raw_right = RAW[right] as f32; - let span = (raw_right - raw_left).max(1.0); - let ratio = (raw as f32 - raw_left) / span; - - (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 + force_from_config_or_fallback(raw, config.map(|cfg| &cfg.index), &RAW, &FORCE_CENTI_N) } -fn raw_to_g3(raw: u32) -> f32 { +fn raw_to_g3(raw: u32, config: Option<&HandForceConfig>) -> f32 { const RAW: [u32; 11] = [ 0, 51562, 252840, 326531, 386571, 415819, 514679, 631745, 678945, 810847, 900422, ]; @@ -875,34 +893,10 @@ fn raw_to_g3(raw: u32) -> f32 { 0.0, 57.0, 257.0, 357.0, 457.0, 557.0, 657.0, 857.0, 1057.0, 1557.0, 2057.0, ]; - if raw <= RAW[0] { - return FORCE_CENTI_N[0] / 100.0; - } - - if raw >= RAW[RAW.len() - 1] { - return FORCE_CENTI_N[FORCE_CENTI_N.len() - 1] / 100.0; - } - - let mut left = 0usize; - let mut right = RAW.len() - 1; - while left + 1 < right { - let mid = (left + right) / 2; - if RAW[mid] <= raw { - left = mid; - } else { - right = mid; - } - } - - let raw_left = RAW[left] as f32; - let raw_right = RAW[right] as f32; - let span = (raw_right - raw_left).max(1.0); - let ratio = (raw as f32 - raw_left) / span; - - (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 + force_from_config_or_fallback(raw, config.map(|cfg| &cfg.middle), &RAW, &FORCE_CENTI_N) } -fn raw_to_g4(raw: u32) -> f32 { +fn raw_to_g4(raw: u32, config: Option<&HandForceConfig>) -> f32 { const RAW: [u32; 11] = [ 0, 33213, 220611, 307383, 369637, 430462, 489659, 584789, 664960, 802749, 926907, ]; @@ -910,34 +904,10 @@ fn raw_to_g4(raw: u32) -> f32 { 0.0, 57.0, 257.0, 357.0, 457.0, 557.0, 657.0, 857.0, 1057.0, 1557.0, 2057.0, ]; - if raw <= RAW[0] { - return FORCE_CENTI_N[0] / 100.0; - } - - if raw >= RAW[RAW.len() - 1] { - return FORCE_CENTI_N[FORCE_CENTI_N.len() - 1] / 100.0; - } - - let mut left = 0usize; - let mut right = RAW.len() - 1; - while left + 1 < right { - let mid = (left + right) / 2; - if RAW[mid] <= raw { - left = mid; - } else { - right = mid; - } - } - - let raw_left = RAW[left] as f32; - let raw_right = RAW[right] as f32; - let span = (raw_right - raw_left).max(1.0); - let ratio = (raw as f32 - raw_left) / span; - - (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 + force_from_config_or_fallback(raw, config.map(|cfg| &cfg.ring), &RAW, &FORCE_CENTI_N) } -fn raw_to_g5(raw: u32) -> f32 { +fn raw_to_g5(raw: u32, config: Option<&HandForceConfig>) -> f32 { const RAW: [u32; 11] = [ 0, 44291, 216657, 301950, 366186, 384791, 496521, 566189, 701459, 845608, 940796, ]; @@ -945,31 +915,7 @@ fn raw_to_g5(raw: u32) -> f32 { 0.0, 57.0, 257.0, 357.0, 457.0, 557.0, 657.0, 857.0, 1057.0, 1557.0, 2057.0, ]; - if raw <= RAW[0] { - return FORCE_CENTI_N[0] / 100.0; - } - - if raw >= RAW[RAW.len() - 1] { - return FORCE_CENTI_N[FORCE_CENTI_N.len() - 1] / 100.0; - } - - let mut left = 0usize; - let mut right = RAW.len() - 1; - while left + 1 < right { - let mid = (left + right) / 2; - if RAW[mid] <= raw { - left = mid; - } else { - right = mid; - } - } - - let raw_left = RAW[left] as f32; - let raw_right = RAW[right] as f32; - let span = (raw_right - raw_left).max(1.0); - let ratio = (raw as f32 - raw_left) / span; - - (FORCE_CENTI_N[left] + ratio * (FORCE_CENTI_N[right] - FORCE_CENTI_N[left])) / 100.0 + force_from_config_or_fallback(raw, config.map(|cfg| &cfg.little), &RAW, &FORCE_CENTI_N) } fn raw_to_g6(raw: u32) -> f32 { @@ -1219,6 +1165,30 @@ fn normalize_pressure_value(value: u32) -> [f32; 2] { mod tests { use super::*; + #[test] + fn raw_to_g1_uses_loaded_thumb_config() { + let config: HandForceConfig = toml::from_str( + r#" + [thumb] + "0.57" = 10 + "2.57" = 20 + + [index] + "0.57" = 1 + [middle] + "0.57" = 1 + [ring] + "0.57" = 1 + [little] + "0.57" = 1 + "#, + ) + .expect("test config should parse"); + + assert_eq!(raw_to_g1(20, Some(&config)), 2.57); + assert_ne!(raw_to_g1(20, None), 2.57); + } + #[test] fn pressure_normalization_makes_low_hand_values_visible() { let [zero_intensity, zero_label] = normalize_pressure_value(4); diff --git a/src/config.rs b/src/config.rs new file mode 100644 index 0000000..fb7a730 --- /dev/null +++ b/src/config.rs @@ -0,0 +1,70 @@ +use serde::Deserialize; +use std::{ + collections::BTreeMap, + fs, + path::{Path, PathBuf}, +}; + +#[derive(Debug, Deserialize)] +pub struct HandForceConfig { + pub thumb: BTreeMap, + pub index: BTreeMap, + pub middle: BTreeMap, + pub ring: BTreeMap, + pub little: BTreeMap, +} + +pub fn try_load_hand_force_config() -> Option { + let path: PathBuf = std::env::current_exe().ok()?.parent()?.join("config.toml"); + load_hand_force_config(&path) +} + +fn load_hand_force_config(path: &Path) -> Option { + let content = fs::read_to_string(path).ok()?; + toml::from_str(&content).ok() +} + +#[cfg(test)] +mod tests { + use super::*; + use std::time::{SystemTime, UNIX_EPOCH}; + + #[test] + fn loads_hand_force_config_toml() { + let path = std::env::temp_dir().join(format!( + "eskin-hand-force-config-{}-{}.toml", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("system clock should be after Unix epoch") + .as_nanos() + )); + fs::write( + &path, + r#" + [thumb] + "0.57" = 35694 + "2.57" = 226640 + + [index] + "0.57" = 45490 + + [middle] + "0.57" = 51562 + + [ring] + "0.57" = 33213 + + [little] + "0.57" = 44291 + "#, + ) + .expect("test config should be writable"); + + let config = load_hand_force_config(&path).expect("valid TOML should load"); + fs::remove_file(&path).expect("test config should be removable"); + + assert_eq!(config.thumb["2.57"], 226640); + assert_eq!(config.index["0.57"], 45490); + } +} diff --git a/src/main.rs b/src/main.rs index c812a2b..43ed8e0 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,6 +2,7 @@ #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] mod app; mod breakout; +mod config; mod connection; mod force; mod matrix;