yanjie/eskin-player
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: yanjie:waic
Branches Tags
yanjie:master yanjie:waic-hand-x yanjie:waic-hand-h yanjie:waic-hand yanjie:waic-finger yanjie:video yanjie:waic
..
compare: yanjie:waic-hand
Branches Tags
yanjie:master yanjie:waic-hand-x yanjie:waic-hand-h yanjie:waic-hand yanjie:waic-finger yanjie:video yanjie:waic

7 Commits
waic ... waic-hand

Author SHA1 Message Date
lenn
9fb4c0edf4 对五个手指分别进行查表插值 2026-07-07 21:13:37 +08:00
lenn
1e3cfdcf21 shader: collapse palm chip background pass and refine dot rendering 2026-07-07 16:35:19 +08:00
lenn
a04b903e96 Integrate hand fingertip force overlays 2026-07-07 09:43:25 +08:00
lenn
c4bccc1747 refactor: 配置面板改造为顶部固定栏 + 压力归一化优化 2026-07-06 14:07:23 +08:00
lenn
5264f0c247 Tune hand-tip and palm chip layout coordinates 
Adjust HandTipMatrix / HandPalmChip center, angle, and size in render.rs and propagate the spacing tweak through shader.wgsl.
 2026-07-03 15:30:25 +08:00
lenn
a999d9c064 Refactor to hand-mode UI and reorganize WGSL shader 
Replace spatial force / stats panels with unified hand force panels; simplify app.rs wiring and reorganize shader.wgsl for the hand rendering layout.
 2026-07-03 13:41:02 +08:00
lenn
71d314ac44 Add finger mode UI and refine breakout/serial integration 2026-07-02 15:22:13 +08:00
14 changed files with 1143 additions and 336 deletions
Expand all files Collapse all files

41
Cargo.lock generated
View File

@@ -1320,6 +1320,7 @@ dependencies = [
"log",
"serialport",
"tobj",
"winresource",
]
[[package]]
@@ -3645,6 +3646,15 @@ dependencies = [
"syn",
]
[[package]]
name = "serde_spanned"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
dependencies = [
"serde_core",
]
[[package]]
name = "serialport"
version = "4.9.0"
@@ -3989,6 +3999,21 @@ dependencies = [
"ahash",
]
[[package]]
name = "toml"
version = "1.1.2+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
dependencies = [
"indexmap",
"serde_core",
"serde_spanned",
"toml_datetime",
"toml_parser",
"toml_writer",
"winnow",
]
[[package]]
name = "toml_datetime"
version = "1.1.1+spec-1.1.0"
@@ -4019,6 +4044,12 @@ dependencies = [
"winnow",
]
[[package]]
name = "toml_writer"
version = "1.1.1+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
[[package]]
name = "tracing"
version = "0.1.44"
@@ -5017,6 +5048,16 @@ dependencies = [
"memchr",
]
[[package]]
name = "winresource"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
dependencies = [
"toml",
"version_check",
]
[[package]]
name = "wit-bindgen"
version = "0.51.0"

3
Cargo.toml
View File

@@ -24,10 +24,11 @@ log = "0.4.29"
tobj = "4.0.4"
gltf = "1.4.1"
[build-dependencies]
anyhow = "1.0.102"
fs_extra = "1.3.0"
winresource = "0.1.31"
[[bin]]
name = "ESkinPlayer"

8
build.rs
View File

@@ -27,6 +27,14 @@ fn main() -> Result<()> {
copy_items(&items, &resource_dir, &copy_options)?;
}
if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
let mut resource = winresource::WindowsResource::new();
resource.set_icon("res/icon.ico");
resource.compile().expect("compile windows icon failed");
}
println!("cargo:rustc-env=RESOURCE_DIR={}", resource_dir.display());
Ok(())

BIN
res/128x128@2x.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

BIN
res/icon.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 41 KiB

524
src/app.rs
View File

@@ -1,6 +1,6 @@
use crate::breakout::{BreakoutGame, control_from_matrix};
use crate::connection::ConnectionManager;
use crate::force::{ForceEstimatorState, HudSpatialForce};
use crate::connection::{ConnectionManager, ConnectionState};
use crate::force::{ForceEstimatorState, HAND_FINGERTIP_COUNT, HudSpatialForce};
use crate::recording::Recorder;
use crate::render::{ActiveMode, FingerMode, HandGatewayMode};
use crate::style::{ONE_DARK_PRO, apply_fonts, apply_theme, layout};
@@ -13,16 +13,28 @@ use crate::{
},
ui::{
ConfigPanelState, ConnectPanelState, FloatingPanelState, MatrixConfigState,
draw_config_panel, draw_export_panel, draw_hand_force_panels, draw_matrix_config_panel,
draw_stats_panel, panel_restore_item,
draw_config_panel, draw_hand_force_panels, panel_restore_item,
},
};
use eframe::{egui, egui_wgpu};
use std::sync::Arc;
use std::{
sync::Arc,
time::{Duration, Instant},
};
const SUMMARY_POINTS_PER_SERIES: usize = 42;
const HAND_FORCE_PANEL_COUNT: usize = 7;
const HAND_FORCE_SEGMENT_COUNTS: [usize; HAND_FORCE_PANEL_COUNT] = [84, 84, 84, 84, 84, 70, 44];
const HAND_IMAGE_SIZE_PX: [f32; 2] = [971.0, 1117.0];
const HAND_FINGERTIP_FORCE_ANCHORS_PX: [[f32; 2]; HAND_FINGERTIP_COUNT] = [
[265.0, 495.0],
[359.0, 260.0],
[482.0, 228.0],
[596.0, 265.0],
[693.0, 370.0],
];
const RATE_UPDATE_INTERVAL: Duration = Duration::from_millis(500);
const DATA_IDLE_PANEL_EXIT_DELAY: Duration = Duration::from_secs(3);
pub struct EskinDesktopApp {
connect_panel: FloatingPanelState,
@@ -44,16 +56,63 @@ pub struct EskinDesktopApp {
hand_signal_histories: [Vec<f32>; HAND_FORCE_PANEL_COUNT],
force_estimator: ForceEstimatorState,
latest_spatial_force: Option<HudSpatialForce>,
latest_hand_spatial_forces: [Option<HudSpatialForce>; HAND_FINGERTIP_COUNT],
spatial_force_panel_force: Option<HudSpatialForce>,
latest_raw_matrix: Vec<u32>,
latest_matrix_rows: u32,
latest_matrix_cols: u32,
last_sample_at: Option<Instant>,
breakout_visible: bool,
breakout_game: BreakoutGame,
live_rates: LiveRateMeters,
context_menu_open: bool,
context_menu_pos: egui::Pos2,
active_mode: ActiveMode,
}
struct LiveRateMeters {
window_started_at: Instant,
window_rx_frames: u64,
window_render_frames: u32,
sample_rate_hz: f32,
render_rate_hz: f32,
}
impl LiveRateMeters {
fn new() -> Self {
Self {
window_started_at: Instant::now(),
window_rx_frames: 0,
window_render_frames: 0,
sample_rate_hz: 0.0,
render_rate_hz: 0.0,
}
}
fn tick_render(&mut self, total_rx_frames: u64) {
if total_rx_frames < self.window_rx_frames {
self.window_rx_frames = total_rx_frames;
self.sample_rate_hz = 0.0;
}
self.window_render_frames = self.window_render_frames.saturating_add(1);
let now = Instant::now();
let elapsed = now.duration_since(self.window_started_at);
if elapsed < RATE_UPDATE_INTERVAL {
return;
}
let seconds = elapsed.as_secs_f32().max(0.001);
let rx_delta = total_rx_frames.saturating_sub(self.window_rx_frames);
self.sample_rate_hz = rx_delta as f32 / seconds;
self.render_rate_hz = self.window_render_frames as f32 / seconds;
self.window_started_at = now;
self.window_rx_frames = total_rx_frames;
self.window_render_frames = 0;
}
}
impl EskinDesktopApp {
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
egui_extras::install_image_loaders(&cc.egui_ctx);
@@ -110,19 +169,18 @@ impl EskinDesktopApp {
hand_signal_histories: std::array::from_fn(|_| Vec::with_capacity(128)),
force_estimator: ForceEstimatorState::new(),
latest_spatial_force: None,
latest_hand_spatial_forces: [None; HAND_FINGERTIP_COUNT],
spatial_force_panel_force: None,
latest_raw_matrix: Vec::new(),
latest_matrix_rows: MATRIX_ROWS,
latest_matrix_cols: MATRIX_COLS,
last_sample_at: None,
breakout_visible: false,
breakout_game: BreakoutGame::default(),
live_rates: LiveRateMeters::new(),
context_menu_open: false,
context_menu_pos: egui::pos2(24.0, 48.0),
active_mode: ActiveMode::Finger(FingerMode {
rows: 12,
cols: 7,
range: 0..7000,
dot: true,
}),
active_mode: ActiveMode::Hand(HandGatewayMode { range: 0..7000 }),
}
}
@@ -144,40 +202,91 @@ impl EskinDesktopApp {
}
fn paint_spatial_force_overlay(&self, ui: &egui::Ui, rect: egui::Rect) {
if !self.recent_sample_is_fresh() {
return;
}
if matches!(self.active_mode, ActiveMode::Hand(_)) {
self.paint_hand_spatial_force_overlay(ui, rect);
return;
}
let Some(force) = self.latest_spatial_force else {
return;
};
let painter = ui.painter();
let center = rect.center();
let magnitude = force.magnitude.clamp(0.0, 1.8);
let length = 34.0 + magnitude * 54.0;
let angle = force.angle_deg.to_radians();
let direction = egui::vec2(angle.cos(), angle.sin());
let end = center + direction * length;
let side = egui::vec2(-direction.y, direction.x);
let color = egui::Color32::from_rgb(255, 196, 54);
let glow = egui::Color32::from_rgba_unmultiplied(255, 196, 54, 58);
paint_spatial_force_arrow(ui.painter(), center, force, 34.0, 54.0);
}
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(
[end, end - direction * 14.0 + side * 7.0],
egui::Stroke::new(2.4, color),
);
painter.line_segment(
[end, end - direction * 14.0 - side * 7.0],
egui::Stroke::new(2.4, color),
);
painter.circle_filled(center, 4.2, color);
fn paint_hand_spatial_force_overlay(&self, ui: &egui::Ui, rect: egui::Rect) {
for (force, anchor_px) in self
.latest_hand_spatial_forces
.iter()
.zip(HAND_FINGERTIP_FORCE_ANCHORS_PX)
{
let Some(force) = force else {
continue;
};
let center = hand_image_pixel_to_screen(rect, anchor_px);
paint_spatial_force_arrow(ui.painter(), center, *force, 20.0, 34.0);
}
}
fn strongest_hand_spatial_force(&self) -> Option<HudSpatialForce> {
self.latest_hand_spatial_forces
.iter()
.flatten()
.copied()
.max_by(|a, b| a.magnitude.total_cmp(&b.magnitude))
}
fn analyze_spatial_force(&mut self, values: &[u32]) {
if matches!(self.config_state.mode, SerialMode::Hand) {
self.latest_hand_spatial_forces = self.force_estimator.analyze_fingertips(values);
self.latest_spatial_force = self.strongest_hand_spatial_force();
} else {
self.latest_spatial_force = self.force_estimator.analyze(values);
self.latest_hand_spatial_forces = [None; HAND_FINGERTIP_COUNT];
}
}
fn connection_has_live_data(&self) -> bool {
matches!(
self.connection.state(),
ConnectionState::Connected | ConnectionState::Streaming
)
}
fn recent_sample_is_fresh(&self) -> bool {
self.last_sample_at
.is_some_and(|sample_at| sample_at.elapsed() <= DATA_IDLE_PANEL_EXIT_DELAY)
}
fn hand_force_panels_visible(&self) -> bool {
self.connection_has_live_data() && self.recent_sample_is_fresh()
}
fn sync_disconnected_live_state(&mut self) {
if self.connection_has_live_data() {
return;
}
self.last_sample_at = None;
self.latest_spatial_force = None;
self.latest_hand_spatial_forces = [None; HAND_FINGERTIP_COUNT];
self.spatial_force_panel_force = None;
}
fn draw_workspace(&mut self, ui: &mut egui::Ui) {
if self.breakout_visible {
self.draw_split_workspace(ui);
} else {
self.draw_wgpu_background_rect(ui, ui.max_rect());
}
let screen = ui.max_rect();
let workspace = egui::Rect::from_min_max(
screen.left_top()
+ egui::vec2(0.0, layout::TITLE_BAR_HEIGHT + layout::CONFIG_BAR_HEIGHT),
screen.right_bottom(),
);
self.draw_wgpu_background_rect(ui, workspace);
}
fn draw_split_workspace(&mut self, ui: &mut egui::Ui) {
@@ -218,6 +327,7 @@ impl EskinDesktopApp {
fn update_pressure_matrix(&mut self) {
if let Some(sample) = self.connection.take_latest_sample() {
self.last_sample_at = Some(Instant::now());
normalize_pressure_sample(
&sample.matrix,
sample.rows,
@@ -230,7 +340,7 @@ impl EskinDesktopApp {
self.latest_matrix_rows = sample.rows;
self.latest_matrix_cols = sample.cols;
self.latest_spatial_force = self.force_estimator.analyze(&sample.matrix);
self.analyze_spatial_force(&sample.matrix);
// Keep JE-Skin's summary path separate from the optional spatial-force vector.
let raw_total = sample
@@ -245,11 +355,9 @@ impl EskinDesktopApp {
self.signal_history.remove(0);
}
if self.config_state.mode == SerialMode::Hand {
update_hand_signal_histories(&mut self.hand_signal_histories, &sample.matrix);
}
}
}
fn draw_title_bar(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
let title_bar_height = layout::TITLE_BAR_HEIGHT;
@@ -362,13 +470,16 @@ impl EskinDesktopApp {
}
}
fn draw_floating_panels(&mut self, ctx: &egui::Context) {
// 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;
// }
fn draw_floating_panels(
&mut self,
ctx: &egui::Context,
stats: crate::serial_core::serial::SerialIoStats,
) {
self.scene_panel.visible = false;
self.connect_panel.visible = false;
self.export_panel.visible = false;
self.matrix_config_panel.visible = false;
self.context_menu_open = false;
if let Some(next_mode) = draw_config_panel(
ctx,
@@ -376,30 +487,20 @@ impl EskinDesktopApp {
&mut self.config_state,
&self.connection,
&self.recorder,
stats,
self.live_rates.sample_rate_hz,
self.live_rates.render_rate_hz,
) {
self.switch_mode(next_mode);
}
match self.config_state.mode {
SerialMode::Finger => {
draw_stats_panel(
self.stats_panel.visible = false;
draw_hand_force_panels(
ctx,
&mut self.stats_panel,
&self.signal_history,
self.latest_spatial_force,
self.hand_force_panels_visible(),
&self.hand_signal_histories,
);
}
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);
}
fn draw_panel_context_menu(&mut self, ctx: &egui::Context) {
let (secondary_clicked, pointer_pos, escape_pressed) = ctx.input(|input| {
@@ -448,17 +549,6 @@ impl EskinDesktopApp {
} else {
panel_restore_item(ui, "统计", &mut self.stats_panel);
}
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
@@ -472,7 +562,6 @@ impl EskinDesktopApp {
self.export_panel.visible = true;
self.matrix_config_panel.visible = true;
self.stats_panel.visible = true;
self.breakout_visible = true;
close_menu = true;
}
});
@@ -497,8 +586,11 @@ impl EskinDesktopApp {
self.connection.disconnect();
self.pressure_matrix.fill([0.0, 0.0]);
self.hand_pressure.clear();
self.last_sample_at = None;
self.force_estimator.reset();
self.latest_spatial_force = None;
self.latest_hand_spatial_forces = [None; HAND_FINGERTIP_COUNT];
self.spatial_force_panel_force = None;
self.signal_history.clear();
self.hand_signal_histories
.iter_mut()
@@ -516,19 +608,81 @@ impl EskinDesktopApp {
}
}
fn hand_image_pixel_to_screen(rect: egui::Rect, point_px: [f32; 2]) -> egui::Pos2 {
let image_uv = egui::vec2(
point_px[0] / HAND_IMAGE_SIZE_PX[0].max(1.0),
point_px[1] / HAND_IMAGE_SIZE_PX[1].max(1.0),
);
let viewport_aspect = rect.width() / rect.height().max(1.0);
let image_aspect = HAND_IMAGE_SIZE_PX[0] / HAND_IMAGE_SIZE_PX[1].max(1.0);
let mut screen_uv = image_uv;
if viewport_aspect > image_aspect {
let image_width = image_aspect / viewport_aspect;
screen_uv.x = image_uv.x * image_width + (1.0 - image_width) * 0.5;
} else {
let image_height = viewport_aspect / image_aspect;
screen_uv.y = image_uv.y * image_height + (1.0 - image_height) * 0.5;
}
egui::pos2(
rect.left() + screen_uv.x * rect.width(),
rect.top() + screen_uv.y * rect.height(),
)
}
fn paint_spatial_force_arrow(
painter: &egui::Painter,
center: egui::Pos2,
force: HudSpatialForce,
base_length: f32,
magnitude_scale: f32,
) {
let magnitude = force.magnitude.clamp(0.0, 1.8);
let length = base_length + magnitude * magnitude_scale;
let angle = force.angle_deg.to_radians();
let direction = egui::vec2(angle.cos(), angle.sin());
let end = center + direction * length;
let side = egui::vec2(-direction.y, direction.x);
let head_length = (length * 0.24).clamp(8.0, 14.0);
let head_width = head_length * 0.5;
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(8.0, glow));
painter.line_segment([center, end], egui::Stroke::new(2.4, color));
painter.line_segment(
[end, end - direction * head_length + side * head_width],
egui::Stroke::new(2.4, color),
);
painter.line_segment(
[end, end - direction * head_length - side * head_width],
egui::Stroke::new(2.4, color),
);
painter.circle_filled(center, 3.8, color);
}
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) {
for (index, (history, sample_count)) in histories.iter_mut().zip(HAND_FORCE_SEGMENT_COUNTS).enumerate() {
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 = match index {
0 => raw_to_g1(raw_total).min(20.6),
1 => raw_to_g2(raw_total).min(20.6),
2 => raw_to_g3(raw_total).min(20.6),
3 => raw_to_g4(raw_total).min(20.6),
4 => raw_to_g5(raw_total).min(20.6),
_ => raw_to_gd(raw_total).min(20.6),
};
// let force = raw_to_g1(raw_total).min(25.6);
let force = if force <= 0.1 { 0.0 } else { force };
history.push(force);
@@ -540,7 +694,7 @@ fn update_hand_signal_histories(
}
}
fn raw_to_g1(raw: u32) -> f32 {
fn raw_to_gd(raw: u32) -> f32 {
const RAW: [u32; 12] = [
0, 21382, 108507, 123183, 147405, 171105, 192395, 250443, 231423, 350560, 396616, 429444,
];
@@ -575,6 +729,181 @@ fn raw_to_g1(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 {
const RAW: [u32; 11] = [
0, 20239, 121454, 171532, 223968, 241467, 293500, 322744, 436294, 523275, 633083,
];
const FORCE_CENTI_N: [f32; 11] = [
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
}
fn raw_to_g2(raw: u32) -> f32 {
const RAW: [u32; 11] = [
0, 5398, 52896, 86945, 122546, 145001, 165933, 220575, 241578, 350285, 449530,
];
const FORCE_CENTI_N: [f32; 11] = [
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
}
fn raw_to_g3(raw: u32) -> f32 {
const RAW: [u32; 11] = [
0, 4920, 35945, 46499, 65566, 69613, 89971, 122321, 146384, 203426, 269474,
];
const FORCE_CENTI_N: [f32; 11] = [
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
}
fn raw_to_g4(raw: u32) -> f32 {
const RAW: [u32; 11] = [
0, 11346, 92229, 139822, 182282, 220004, 259898, 307303, 377922, 460755, 587834,
];
const FORCE_CENTI_N: [f32; 11] = [
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
}
fn raw_to_g5(raw: u32) -> f32 {
const RAW: [u32; 11] = [
0, 10081, 40910, 49944, 64291, 68299, 79282, 97767, 113567, 140520, 167132,
];
const FORCE_CENTI_N: [f32; 11] = [
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
}
fn paint_split_viewport_shell(
ui: &egui::Ui,
rect: egui::Rect,
@@ -648,27 +977,58 @@ fn normalize_pressure_samples(raw: &[u32]) -> PressureSamples {
fn normalize_pressure_value(value: u32) -> [f32; 2] {
const RANGE_MIN: f32 = 0.0;
const RANGE_MAX: f32 = 7000.0;
const DISPLAY_GAMMA: f32 = 0.45;
let raw_value = value as f32;
let mapped = ((raw_value - RANGE_MIN) / (RANGE_MAX - RANGE_MIN)).clamp(0.0, 1.0);
let intensity = if raw_value <= RANGE_MIN + 4.0 {
0.0
} else {
mapped.powf(DISPLAY_GAMMA)
};
let display_value = if raw_value <= RANGE_MIN + 4.0 {
0.0
} else {
raw_value.round().min(9999.0)
};
[mapped, display_value]
[intensity, display_value]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pressure_normalization_makes_low_hand_values_visible() {
let [zero_intensity, zero_label] = normalize_pressure_value(4);
assert_eq!(zero_intensity, 0.0);
assert_eq!(zero_label, 0.0);
let [low_intensity, low_label] = normalize_pressure_value(100);
assert!(
low_intensity > 0.10,
"low hand-gateway values should be visible in the wgpu dot matrix"
);
assert_eq!(low_label, 100.0);
let [max_intensity, max_label] = normalize_pressure_value(7000);
assert_eq!(max_intensity, 1.0);
assert_eq!(max_label, 7000.0);
}
}
impl eframe::App for EskinDesktopApp {
fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
let ctx = ui.ctx().clone();
let stats = self.connection.stats();
self.live_rates.tick_render(stats.rx_frames);
self.update_pressure_matrix();
self.sync_disconnected_live_state();
self.draw_workspace(ui);
self.draw_title_bar(ui, frame);
self.draw_floating_panels(&ctx);
self.draw_panel_context_menu(&ctx);
self.draw_floating_panels(&ctx, stats);
// Keep repainting while the wgpu background is a realtime viewport.
ctx.request_repaint();

34
src/breakout.rs
View File

@@ -20,6 +20,7 @@ enum BreakoutPhase {
Idle,
Running,
Paused,
Won,
Over,
}
@@ -46,7 +47,6 @@ pub struct BreakoutGame {
score: u32,
combo: u32,
lives: u32,
level: u32,
last_time: Option<f64>,
previous_pause_gesture: bool,
pause_locked_until: f64,
@@ -63,7 +63,6 @@ impl Default for BreakoutGame {
score: 0,
combo: 0,
lives: 3,
level: 1,
last_time: None,
previous_pause_gesture: false,
pause_locked_until: 0.0,
@@ -150,7 +149,6 @@ impl BreakoutGame {
status_chip(ui, "分数", self.score.to_string(), ACCENT_GREEN);
status_chip(ui, "连击", self.combo.to_string(), ACCENT_ORANGE);
status_chip(ui, "生命", self.lives.to_string(), ACCENT_RED);
status_chip(ui, "关卡", self.level.to_string(), ACCENT_BLUE);
});
ui.add_space(7.0);
@@ -191,12 +189,11 @@ impl BreakoutGame {
self.score = 0;
self.combo = 0;
self.lives = 3;
self.level = 1;
self.rebuild_bricks();
}
fn start(&mut self) {
if self.phase == BreakoutPhase::Over {
if self.phase == BreakoutPhase::Over || self.phase == BreakoutPhase::Won {
self.reset();
}
if self.phase != BreakoutPhase::Running {
@@ -219,7 +216,10 @@ impl BreakoutGame {
let threshold = pressure_pause_threshold();
let active = top_force >= threshold;
if active && !self.previous_pause_gesture && now >= self.pause_locked_until {
if self.phase == BreakoutPhase::Idle || self.phase == BreakoutPhase::Over {
if matches!(
self.phase,
BreakoutPhase::Idle | BreakoutPhase::Over | BreakoutPhase::Won
) {
self.start();
} else {
self.toggle_pause();
@@ -249,7 +249,7 @@ impl BreakoutGame {
}
fn launch_ball(&mut self) {
let direction = if self.level % 2 == 0 { -0.24 } else { 0.24 };
let direction = 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;
}
@@ -324,9 +324,8 @@ impl BreakoutGame {
}
if self.bricks.iter().all(|brick| !brick.alive) {
self.level += 1;
self.rebuild_bricks();
self.launch_ball();
self.phase = BreakoutPhase::Won;
self.ball_vel = egui::Vec2::ZERO;
}
}
@@ -358,6 +357,7 @@ impl BreakoutGame {
BreakoutPhase::Idle => "待机",
BreakoutPhase::Running => "运行",
BreakoutPhase::Paused => "暂停",
BreakoutPhase::Won => "过关",
BreakoutPhase::Over => "结束",
}
}
@@ -387,6 +387,7 @@ impl BreakoutGame {
if self.phase == BreakoutPhase::Idle
|| self.phase == BreakoutPhase::Paused
|| self.phase == BreakoutPhase::Won
|| self.phase == BreakoutPhase::Over
{
paint_center_overlay(&painter, rect, self.phase);
@@ -403,6 +404,10 @@ pub fn control_from_matrix(raw: &[u32], rows: u32, cols: u32) -> BreakoutControl
let cols = cols.max(1) as usize;
let sample_rows = rows.min(2);
let sample_cols = cols.min(2);
let top_gesture_rows = rows.min(1);
let top_gesture_cols = (cols / 3).clamp(1, cols);
let top_gesture_col_start = (cols - top_gesture_cols) / 2;
let top_gesture_col_end = top_gesture_col_start + top_gesture_cols;
let avg = |row_start: usize, row_end: usize, col_start: usize, col_end: usize| -> f32 {
let mut sum = 0.0;
let mut count = 0.0;
@@ -430,7 +435,12 @@ pub fn control_from_matrix(raw: &[u32], rows: u32, cols: u32) -> BreakoutControl
let left_force = tl + bl;
let right_force = tr + br;
let top_force = tl + tr;
let top_force = avg(
0,
top_gesture_rows,
top_gesture_col_start,
top_gesture_col_end,
);
let span = 1200.0_f32.max((PRESSURE_RANGE_MAX - PRESSURE_RANGE_MIN) * 0.22);
let raw_axis = ((right_force - left_force) / span).clamp(-1.0, 1.0);
let axis = if raw_axis.abs() < 0.045 {
@@ -485,6 +495,7 @@ fn status_color(phase: BreakoutPhase) -> egui::Color32 {
BreakoutPhase::Idle => ONE_DARK_PRO.text_dim,
BreakoutPhase::Running => ACCENT_GREEN,
BreakoutPhase::Paused => ACCENT_ORANGE,
BreakoutPhase::Won => ACCENT_GREEN,
BreakoutPhase::Over => ACCENT_RED,
}
}
@@ -607,6 +618,7 @@ fn paint_center_overlay(painter: &egui::Painter, rect: egui::Rect, phase: Breako
let (title, detail) = match phase {
BreakoutPhase::Idle => ("按压顶部或点击开始", "左右分区压力控制挡板"),
BreakoutPhase::Paused => ("已暂停", "再次按压顶部、P 或点击暂停继续"),
BreakoutPhase::Won => ("恭喜过关", "按压顶部、点击或空格重新开始"),
BreakoutPhase::Over => ("游戏结束", "点击或空格重开"),
BreakoutPhase::Running => ("", ""),
};

39
src/force.rs
View File

@@ -1,6 +1,7 @@
use crate::serial_core::multi_dim_force::PztProcessor;
const FINGER_SAMPLE_COUNT: usize = 84;
pub const FINGER_SAMPLE_COUNT: usize = 84;
pub const HAND_FINGERTIP_COUNT: usize = 5;
const MIN_TANGENTIAL_MAGNITUDE: f32 = 0.02;
#[derive(Debug, Clone, Copy)]
@@ -11,17 +12,22 @@ pub struct HudSpatialForce {
pub struct ForceEstimatorState {
pzt_processor: PztProcessor,
fingertip_processors: [PztProcessor; HAND_FINGERTIP_COUNT],
}
impl ForceEstimatorState {
pub fn new() -> Self {
Self {
pzt_processor: PztProcessor::new(),
fingertip_processors: std::array::from_fn(|_| PztProcessor::new()),
}
}
pub fn reset(&mut self) {
self.pzt_processor.reset_baseline();
self.fingertip_processors
.iter_mut()
.for_each(PztProcessor::reset_baseline);
}
pub fn analyze(&mut self, values: &[u32]) -> Option<HudSpatialForce> {
@@ -40,6 +46,37 @@ impl ForceEstimatorState {
magnitude: analysis.magnitude,
})
}
pub fn analyze_fingertips(
&mut self,
values: &[u32],
) -> [Option<HudSpatialForce>; HAND_FINGERTIP_COUNT] {
let mut forces = [None; HAND_FINGERTIP_COUNT];
for (tip_index, processor) in self.fingertip_processors.iter_mut().enumerate() {
let start = tip_index * FINGER_SAMPLE_COUNT;
let end = start + FINGER_SAMPLE_COUNT;
let Some(segment) = values.get(start..end) else {
break;
};
let pzt_values = segment
.iter()
.map(|value| *value as f32)
.collect::<Vec<_>>();
forces[tip_index] = processor
.get_pzt_analysis(&pzt_values)
.ok()
.filter(|analysis| analysis.magnitude > MIN_TANGENTIAL_MAGNITUDE)
.map(|analysis| HudSpatialForce {
angle_deg: analysis.angle_deg,
magnitude: analysis.magnitude,
});
}
forces
}
}
impl Default for ForceEstimatorState {

5
src/main.rs
View File

@@ -20,12 +20,15 @@ use eframe::egui;
fn main() -> eframe::Result<()> {
env_logger::init();
let window_icon = eframe::icon_data::from_png_bytes(include_bytes!("../res/128x128@2x.png"))
.expect("load window icon failed");
let options = eframe::NativeOptions {
renderer: eframe::Renderer::Wgpu,
viewport: egui::ViewportBuilder::default()
.with_inner_size([1920.0, 1080.0])
.with_min_inner_size([1280.0, 720.0])
.with_decorations(false),
.with_decorations(false)
.with_icon(window_icon),
..Default::default()
};

71
src/render.rs
View File

@@ -44,43 +44,43 @@ pub struct HandGatewayMode {
const HAND_TIP_MATRICES: [HandTipMatrix; 5] = [
HandTipMatrix {
center_px: [260.0, 490.0],
center_px: [265.0, 495.0],
size_px: [70.0, 120.0],
angle_rad: -0.45,
angle_rad: -0.40,
},
HandTipMatrix {
center_px: [360.0, 255.0],
center_px: [359.0, 260.0],
size_px: [70.0, 120.0],
angle_rad: -0.05,
angle_rad: -0.17,
},
HandTipMatrix {
center_px: [485.0, 225.0],
center_px: [482.0, 228.0],
size_px: [70.0, 120.0],
angle_rad: 0.0,
angle_rad: -0.03,
},
HandTipMatrix {
center_px: [595.0, 260.0],
center_px: [596.0, 265.0],
size_px: [70.0, 120.0],
angle_rad: 0.12,
angle_rad: 0.10,
},
HandTipMatrix {
center_px: [705.0, 385.0],
center_px: [693.0, 370.0],
size_px: [70.0, 120.0],
angle_rad: 0.28,
angle_rad: 0.22,
},
];
const HAND_PALM_CHIPS: [HandPalmChip; 2] = [
HandPalmChip {
center_px: [538.0, 608.0],
size_px: [248.0, 82.0],
angle_rad: 0.06,
center_px: [530.0, 593.0],
size_px: [258.0, 88.0],
angle_rad: 0.12,
rows: 5,
cols: 14,
},
HandPalmChip {
center_px: [606.0, 780.0],
size_px: [72.0, 214.0],
center_px: [610.0, 778.0],
size_px: [82.0, 228.0],
angle_rad: 0.05,
rows: 11,
cols: 4,
@@ -90,6 +90,7 @@ const HAND_PALM_CHIPS: [HandPalmChip; 2] = [
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;
const HAND_TIP_DOT_LOCAL_Y_OFFSET_PX: f32 = 14.0;
// 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.
@@ -1144,7 +1145,7 @@ fn build_hand_membrane_instances(image_width: f32, image_height: f32) -> Vec<Gly
.map(|tip| {
let uv_x = tip.center_px[0] / image_width.max(1.0);
let uv_y = tip.center_px[1] / image_height.max(1.0);
let membrane_size = [tip.size_px[0] * 1.62, tip.size_px[1] * 1.56];
let membrane_size = [tip.size_px[0] * 1.44, tip.size_px[1] * 1.36];
GlyphInstance {
// Membrane shaders read xy as hand.png UV.
@@ -1202,7 +1203,8 @@ fn build_hand_dot_instances(
// Lay out a rows x cols matrix in fingertip-local pixel space.
let local_x = (col as f32 - cols as f32 / 2.0 + 0.5) / cols as f32 * tip.size_px[0];
let local_y = (row as f32 - rows as f32 / 2.0 + 0.5) / rows as f32 * tip.size_px[1];
let local_y = (row as f32 - rows as f32 / 2.0 + 0.5) / rows as f32 * tip.size_px[1]
+ HAND_TIP_DOT_LOCAL_Y_OFFSET_PX;
// Rotate the local matrix so it follows the direction of the finger.
let x = tip.center_px[0] + local_x * cos - local_y * sin;
@@ -1238,16 +1240,16 @@ fn build_hand_palm_dot_instances(
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];
// Palm films can float slightly beyond the hand artwork, similar to fingertip membranes.
let active_size = [chip.size_px[0] * 0.86, chip.size_px[1] * 0.86];
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 index = hand_palm_pressure_index(chip_index, row, col, chip.rows, chip.cols);
let [normalized, display_value] =
sample_pressure_at(pressure, offset + index, index);
@@ -1275,6 +1277,14 @@ fn build_hand_palm_dot_instances(
instances
}
fn hand_palm_pressure_index(chip_index: usize, row: u32, col: u32, rows: u32, cols: u32) -> usize {
if chip_index == 0 {
(col * rows + (rows - 1 - row)) as usize
} else {
(row * cols + col) as usize
}
}
fn sample_pressure_at(pressure: &[[f32; 2]], index: usize, fallback_index: usize) -> [f32; 2] {
pressure
.get(index)
@@ -1406,3 +1416,24 @@ impl GlyphInstance {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hand_palm_horizontal_uses_column_major_pressure_order() {
assert_eq!(hand_palm_pressure_index(0, 0, 0, 5, 14), 4);
assert_eq!(hand_palm_pressure_index(0, 1, 0, 5, 14), 3);
assert_eq!(hand_palm_pressure_index(0, 0, 1, 5, 14), 9);
assert_eq!(hand_palm_pressure_index(0, 4, 13, 5, 14), 65);
}
#[test]
fn hand_palm_vertical_keeps_row_major_pressure_order() {
assert_eq!(hand_palm_pressure_index(1, 0, 0, 11, 4), 0);
assert_eq!(hand_palm_pressure_index(1, 0, 1, 11, 4), 1);
assert_eq!(hand_palm_pressure_index(1, 1, 0, 11, 4), 4);
assert_eq!(hand_palm_pressure_index(1, 10, 3, 11, 4), 43);
}
}

5
src/serial_core/serial.rs
View File

@@ -14,6 +14,7 @@ const DEFAULT_HAND_GATEWAY_NODE_SAMPLE_COUNTS: &[u16] = &[84, 84, 84, 84, 84, 70
pub struct SerialIoStats {
pub rx_bytes: u64,
pub tx_bytes: u64,
pub rx_frames: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -101,6 +102,8 @@ fn run_tactile_a_loop(
recorder.add_frame(&pressures);
}
let _ = sample_tx.try_send(vals);
io_stats.rx_frames += 1;
publish_stats(stats_tx, io_stats);
}
}
}
@@ -191,6 +194,8 @@ fn run_hand_gateway_loop(
recorder.add_frame(&pressures);
}
let _ = sample_tx.try_send(vals);
io_stats.rx_frames += 1;
publish_stats(stats_tx, io_stats);
}
}
}

1
src/style.rs
View File

@@ -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 = 38.0;
pub const CENTER_PANEL_TOP: f32 = 48.0;
pub const LEFT_X: f32 = 24.0;
pub const RIGHT_X: f32 = 1328.0;

499
src/ui.rs
View File

@@ -104,10 +104,10 @@ impl Default for ConfigPanelState {
.unwrap_or_else(|| "COM3".to_owned());
Self {
mode: SerialMode::Finger,
mode: SerialMode::Hand,
port,
available_ports,
baud_rate: 921_600,
baud_rate: SerialMode::Hand.baud_rate(),
data_bits: 8,
stop_bits: 1,
parity: Parity::None,
@@ -126,7 +126,7 @@ impl Default for ConnectPanelState {
let port = serial_enum().unwrap_or_default();
let selected_port = port.first().cloned().unwrap_or_default();
Self {
mode: SerialMode::Finger,
mode: SerialMode::Hand,
port,
selected_port,
duration: 10,
@@ -387,62 +387,216 @@ fn draw_connect_action_row(
pub fn draw_config_panel(
ctx: &egui::Context,
panel: &mut FloatingPanelState,
_panel: &mut FloatingPanelState,
config: &mut ConfigPanelState,
connection: &ConnectionManager,
recorder: &Recorder,
_stats: SerialIoStats,
sample_rate_hz: f32,
render_rate_hz: f32,
) -> Option<SerialMode> {
let mut changed_mode = None;
let changed_mode = None;
let conn_state = connection.state();
let stats = connection.stats();
let panel_width = responsive_panel_width(ctx, 560.0, 340.0);
config.connected = matches!(
conn_state,
ConnectionState::Connected | ConnectionState::Streaming
);
draw_floating_panel(ctx, panel, "配置", "config_panel", 560.0, 340.0, |ui| {
ui.set_min_width(panel_width);
ui.set_max_width(panel_width);
let screen = ctx.content_rect();
let bar_rect = egui::Rect::from_min_size(
egui::pos2(screen.left(), screen.top() + layout::TITLE_BAR_HEIGHT),
egui::vec2(screen.width(), layout::CONFIG_BAR_HEIGHT),
);
if let Some(mode) = draw_mode_row(ui, config) {
changed_mode = Some(mode);
egui::Area::new(egui::Id::new("config_top_bar"))
.fixed_pos(bar_rect.min)
.order(egui::Order::Foreground)
.show(ctx, |ui| {
ui.set_min_size(bar_rect.size());
ui.painter().rect_filled(
ui.max_rect(),
egui::CornerRadius::ZERO,
ONE_DARK_PRO.panel_deep,
);
ui.painter().line_segment(
[ui.max_rect().left_top(), ui.max_rect().right_top()],
egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
);
ui.painter().line_segment(
[ui.max_rect().left_bottom(), ui.max_rect().right_bottom()],
egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
);
ui.add_space(5.0);
ui.horizontal(|ui| {
ui.add_space(8.0);
ui.spacing_mut().item_spacing = egui::vec2(8.0, 0.0);
config.mode = SerialMode::Hand;
config.baud_rate = SerialMode::Hand.baud_rate();
ui.colored_label(dim_text(), "配置面板");
ui.add_space(8.0);
ui.colored_label(dim_text(), "模式");
ui.add_sized(
egui::vec2(102.0, 28.0),
style::mode_button("手掌模块", true),
);
ui.add_space(12.0);
ui.label(style::field_label("端口"));
egui::ComboBox::from_id_salt("config_top_bar_ports")
.width(180.0)
.selected_text(if config.port.is_empty() {
"无可用串口".to_owned()
} else {
config.port.clone()
})
.show_ui(ui, |ui| {
for port in &config.available_ports {
ui.selectable_value(&mut config.port, port.clone(), port.as_str());
}
});
if ui
.add(style::icon_button(
egui::RichText::new("⟳").color(ONE_DARK_PRO.text).size(16.0),
METRICS.icon_button,
))
.on_hover_text("刷新串口")
.clicked()
{
refresh_config_ports(config);
}
// draw_mode_row(ui, config);
ui.separator();
draw_connection_row(ui, config, connection, recorder, conn_state);
ui.add_space(10.0);
ui.label(style::value_text(format!("波特率 {}", config.baud_rate)));
ui.add_space(10.0);
ui.colored_label(dim_text(), "状态");
ui.colored_label(
connection_status_color(conn_state),
connection_status_text(conn_state),
);
ui.add_space(8.0);
// Legacy serial parameter grid is intentionally kept commented for future hardware:
// draw_serial_grid(ui, config);
// ui.add_space(8.0);
draw_mode_body(ui, config, conn_state, stats);
let is_connected = matches!(
conn_state,
ConnectionState::Connected | ConnectionState::Streaming
);
let button_text = if is_connected { "断开" } else { "连接" };
if ui
.add_sized(
egui::vec2(118.0, 28.0),
if is_connected {
style::danger_button(button_text)
} else {
style::primary_button(button_text)
},
)
.clicked()
{
if is_connected {
connection.disconnect();
} else if !config.port.is_empty() {
connection.connect(
&config.port,
12,
7,
config.mode.baud_rate(),
config.mode.protocol(),
recorder.clone(),
);
}
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.label(style::value_text(format!("{render_rate_hz:.1} Hz")));
ui.colored_label(dim_text(), "画面刷新率");
ui.add_space(18.0);
ui.label(style::value_text(format!("{sample_rate_hz:.1} Hz")));
ui.colored_label(dim_text(), "采样率");
});
});
});
changed_mode
}
fn draw_mode_row(ui: &mut egui::Ui, config: &mut ConfigPanelState) -> Option<SerialMode> {
let mut changed_to = None;
ui.horizontal_wrapped(|ui| {
ui.colored_label(dim_text(), "模式");
ui.add_space(12.0);
pub fn draw_spatial_force_panel(
ctx: &egui::Context,
force: Option<HudSpatialForce>,
force_history: &[f32],
) {
let Some(force) = force else {
return;
};
if mode_button(ui, &mut config.mode, SerialMode::Finger, "指尖模块") {
changed_to = Some(SerialMode::Finger)
let target_visible = has_recent_resultant_force(force_history);
let anim = ctx.animate_bool(egui::Id::new("spatial_force_panel_enter"), target_visible);
if anim <= 0.01 {
return;
}
if mode_button(ui, &mut config.mode, SerialMode::Hand, "手掌模块") {
changed_to = Some(SerialMode::Hand)
}
// mode_button(ui, &mut config.mode, SerialMode::Model, "模型");
// Legacy reconnect controls. Current sensors run fixed 921600 baud without auto-reconnect UI.
// ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
// ui.checkbox(&mut config.auto_reconnect, "自动");
// ui.colored_label(dim_text(), "重连");
// });
let target_anim = if target_visible { 1.0 } else { 0.0 };
if (anim - target_anim).abs() > 0.001 {
ctx.request_repaint();
}
let alpha = (anim * 242.0).round() as u8;
let panel_width = responsive_panel_width(ctx, 380.0, 260.0);
let panel_height = responsive_panel_height(ctx, 340.0, 220.0);
let viewport = viewport_panel_rect(ctx);
let pos = egui::pos2(
viewport.right() - panel_width,
viewport.bottom() - panel_height - PANEL_VIEWPORT_MARGIN,
);
egui::Area::new(egui::Id::new("spatial_force_panel"))
.fixed_pos(pos)
.constrain_to(viewport)
.order(egui::Order::Foreground)
.show(ctx, |ui| {
faded_panel_frame(ctx, alpha).show(ui, |ui| {
ui.set_min_width(panel_width);
ui.set_max_width(panel_width);
ui.set_min_height(panel_height);
let text_dim = color_alpha(ONE_DARK_PRO.text_dim, alpha);
let accent = color_alpha(ACCENT_ORANGE, alpha);
let green = color_alpha(ACCENT_GREEN, alpha);
ui.horizontal(|ui| {
ui.colored_label(accent, "3D FORCE");
ui.label(egui::RichText::new("三维力方向").color(text_dim).size(17.0));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.colored_label(
green,
egui::RichText::new("LIVE").color(green).size(12.0),
);
});
});
ui.separator();
changed_to
ui.vertical_centered(|ui| {
let gauge_size = (panel_height - 52.0).min(panel_width - 24.0).max(168.0);
let (rect, _) = ui.allocate_exact_size(
egui::vec2(gauge_size, gauge_size),
egui::Sense::hover(),
);
paint_spatial_force_gauge(ui.painter(), rect, force, alpha);
});
});
});
}
fn draw_mode_row(ui: &mut egui::Ui, config: &mut ConfigPanelState) -> Option<SerialMode> {
config.mode = SerialMode::Hand;
config.baud_rate = SerialMode::Hand.baud_rate();
ui.horizontal_wrapped(|ui| {
ui.colored_label(dim_text(), "Mode");
ui.add_space(12.0);
ui.label(style::panel_title("Hand Gateway"));
});
None
}
fn draw_connection_row(
@@ -609,47 +763,22 @@ fn draw_mode_body(
config: &mut ConfigPanelState,
conn_state: ConnectionState,
stats: SerialIoStats,
sample_rate_hz: f32,
render_rate_hz: f32,
) {
group_frame().show(ui, |ui| match config.mode {
SerialMode::Finger => {
// Legacy module-address controls for older devices:
// ui.horizontal(|ui| {
// ui.label(style::field_label("模块地址"));
// ui.add_sized(
// egui::vec2(80.0, METRICS.field_height),
// egui::DragValue::new(&mut config.module_addr).range(1..=247),
// );
// ui.add_space(16.0);
// if ui.add(tag_button("读取信息")).clicked() {}
// if ui.add(tag_button("探测")).clicked() {}
// });
draw_status_bytes_row(ui, conn_state, stats);
let _ = (config.mode, conn_state, stats);
draw_realtime_rate_row(ui, sample_rate_hz, render_rate_hz);
}
SerialMode::Hand => {
// Legacy manual-TX controls for older hand-module debugging:
// ui.horizontal(|ui| {
// ui.label(style::field_label("发送"));
// ui.add_sized(
// egui::vec2(300.0, METRICS.field_height),
// egui::TextEdit::singleline(&mut config.manual_tx),
// );
// if ui.add(tag_button("发送")).clicked() {}
// if ui.add(tag_button("清空")).clicked() {
// config.manual_tx.clear();
// }
// });
draw_status_bytes_row(ui, conn_state, stats);
} // SerialMode::Model => {
// ui.horizontal(|ui| {
// ui.label(style::field_label("模型"));
// ui.add_sized(
// egui::vec2(300.0, METRICS.field_height),
// egui::TextEdit::singleline(&mut config.model_path),
// );
// if ui.add(tag_button("加载")).clicked() {}
// if ui.add(tag_button("运行")).clicked() {}
// });
// }
fn draw_realtime_rate_row(ui: &mut egui::Ui, sample_rate_hz: f32, render_rate_hz: f32) {
group_frame().show(ui, |ui| {
ui.horizontal_wrapped(|ui| {
ui.colored_label(dim_text(), "实时采样率");
ui.label(style::value_text(format!("{sample_rate_hz:.1} Hz")));
ui.add_space(18.0);
ui.colored_label(dim_text(), "画面刷新率");
ui.label(style::value_text(format!("{render_rate_hz:.1} Hz")));
});
});
}
@@ -828,14 +957,17 @@ pub fn draw_stats_panel(
const FORCE_CHART_MAX_N: f32 = 25.6;
const FORCE_CHART_SAMPLE_SECONDS: f32 = 0.1;
const FORCE_PANEL_ACTIVE_TAIL: usize = 8;
const FORCE_PANEL_EXIT_DELAY_SECONDS: f64 = 3.0;
const HAND_FORCE_PANEL_MIN_WIDTH: f32 = 220.0;
const HAND_FORCE_PANEL_MAX_WIDTH: f32 = 500.0;
const HAND_FORCE_PANEL_MIN_HEIGHT: f32 = 104.0;
const HAND_FORCE_PANEL_MAX_HEIGHT: f32 = 190.0;
const HAND_FORCE_PANEL_GAP: f32 = 12.0;
const HAND_FORCE_PANEL_MIN_WIDTH: f32 = 160.0;
const HAND_FORCE_PANEL_MAX_WIDTH: f32 = 560.0;
const HAND_FORCE_PANEL_MIN_HEIGHT: f32 = 72.0;
const HAND_FORCE_PANEL_MAX_HEIGHT: f32 = 230.0;
const HAND_FORCE_PANEL_GAP: f32 = 20.0;
const HAND_FORCE_PANEL_SIDE_MARGIN: f32 = 24.0;
const HAND_FORCE_PANEL_VERTICAL_MARGIN: f32 = 28.0;
const HAND_FORCE_CENTER_MIN_WIDTH: f32 = 420.0;
const HAND_FORCE_CENTER_MAX_WIDTH: f32 = 820.0;
const HAND_FORCE_PANEL_TITLES: [(&str, &str); 7] = [
("T1", "拇指"),
("T2", "食指"),
@@ -855,15 +987,14 @@ fn has_recent_resultant_force(values: &[f32]) -> bool {
}
pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[Vec<f32>]) {
let hand_active = histories
.iter()
.any(|history| has_recent_resultant_force(history));
let target_visible = visible && hand_active;
let screen = ctx.content_rect();
let side_margin = HAND_FORCE_PANEL_SIDE_MARGIN.min((screen.width() * 0.025).max(10.0));
let vertical_margin = HAND_FORCE_PANEL_VERTICAL_MARGIN.min((screen.height() * 0.04).max(10.0));
let gap = HAND_FORCE_PANEL_GAP.min((screen.height() * 0.018).max(6.0));
let side_width = ((screen.width() - side_margin * 4.0) * 0.25).max(0.0);
let gap = HAND_FORCE_PANEL_GAP.min((screen.height() * 0.024).max(12.0));
let reserved_center_width = (screen.width() * 0.42)
.clamp(HAND_FORCE_CENTER_MIN_WIDTH, HAND_FORCE_CENTER_MAX_WIDTH)
.min((screen.width() - side_margin * 2.0).max(0.0));
let side_width = ((screen.width() - reserved_center_width - side_margin * 2.0) * 0.5).max(0.0);
let panel_width = side_width
.min(HAND_FORCE_PANEL_MAX_WIDTH)
.max(HAND_FORCE_PANEL_MIN_WIDTH.min(side_width));
@@ -871,17 +1002,16 @@ pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[V
let right_x = screen.right() - side_margin - panel_width;
let left_count = 4usize;
let right_count = HAND_FORCE_PANEL_TITLES.len() - left_count;
let available_height =
(screen.height() - layout::TITLE_BAR_HEIGHT - vertical_margin * 2.0).max(0.0);
let chrome_height = layout::TITLE_BAR_HEIGHT + layout::CONFIG_BAR_HEIGHT;
let available_height = (screen.height() - chrome_height - vertical_margin * 2.0).max(0.0);
let panel_height = ((available_height - (left_count - 1) as f32 * gap) / left_count as f32)
.clamp(
HAND_FORCE_PANEL_MIN_HEIGHT.min(available_height),
HAND_FORCE_PANEL_MAX_HEIGHT,
);
.max(0.0)
.min(HAND_FORCE_PANEL_MAX_HEIGHT)
.max(HAND_FORCE_PANEL_MIN_HEIGHT.min(available_height / left_count as f32));
let left_height = left_count as f32 * panel_height + (left_count - 1) as f32 * gap;
let right_height =
right_count as f32 * panel_height + (right_count.saturating_sub(1)) as f32 * gap;
let min_top = screen.top() + layout::TITLE_BAR_HEIGHT + vertical_margin;
let min_top = screen.top() + chrome_height + vertical_margin;
let left_top = (screen.center().y - left_height * 0.5).max(min_top);
let right_top = (screen.center().y - right_height * 0.5).max(min_top);
@@ -903,7 +1033,8 @@ pub fn draw_hand_force_panels(ctx: &egui::Context, visible: bool, histories: &[V
egui::Id::new(format!("hand_force_panel_{index}")),
egui::pos2(target_x, target_y),
egui::vec2(panel_width, panel_height),
target_visible,
index < left_count,
visible,
code,
title,
history,
@@ -916,12 +1047,35 @@ fn draw_force_chart_area(
id: egui::Id,
target_pos: egui::Pos2,
size: egui::Vec2,
from_left: bool,
target_visible: bool,
code: &'static str,
title: &'static str,
values: &[f32],
) {
let anim = ctx.animate_bool(id.with("enter"), target_visible);
let now = ctx.input(|input| input.time);
let active = target_visible && has_recent_resultant_force(values);
let state_id = id.with("active_state");
let mut last_active_at = ctx.data_mut(|data| data.get_temp::<f64>(state_id));
if active {
last_active_at = Some(now);
ctx.data_mut(|data| data.insert_temp(state_id, now));
} else if !target_visible {
last_active_at = None;
ctx.data_mut(|data| data.remove::<f64>(state_id));
}
let target_visible =
last_active_at.is_some_and(|active_at| now - active_at <= FORCE_PANEL_EXIT_DELAY_SECONDS);
let anim_id = id.with("enter");
let anim_seeded_id = id.with("enter_seeded");
let anim_seeded = ctx.data_mut(|data| data.get_temp::<bool>(anim_seeded_id).unwrap_or(false));
if target_visible && !anim_seeded {
ctx.animate_bool(anim_id, false);
ctx.data_mut(|data| data.insert_temp(anim_seeded_id, true));
}
let anim = ctx.animate_bool(anim_id, target_visible);
if anim <= 0.01 {
return;
@@ -933,20 +1087,27 @@ fn draw_force_chart_area(
}
let eased = ease_in_out(anim);
let hidden_y = ctx.content_rect().bottom() + HAND_FORCE_PANEL_GAP;
let y = egui::lerp(hidden_y..=target_pos.y, eased);
let hidden_x = if from_left {
ctx.content_rect().left() - size.x - HAND_FORCE_PANEL_GAP
} else {
ctx.content_rect().right() + HAND_FORCE_PANEL_GAP
};
let x = egui::lerp(hidden_x..=target_pos.x, eased);
egui::Area::new(id)
.fixed_pos(egui::pos2(target_pos.x, y))
.fixed_pos(egui::pos2(x, target_pos.y))
.constrain_to(viewport_panel_rect(ctx))
.order(egui::Order::Foreground)
.show(ctx, |ui| {
panel_frame(ctx).show(ui, |ui| {
let padding = METRICS.panel_padding as f32;
let inner_width = (size.x - padding * 2.0).max(80.0);
let inner_height = (size.y - padding * 2.0).max(48.0);
ui.spacing_mut().item_spacing = egui::vec2(METRICS.item_gap, 6.0);
ui.set_min_width(size.x);
ui.set_max_width(size.x);
ui.set_min_height(size.y);
draw_force_chart_panel_contents(ui, code, title, values, size.y);
ui.set_min_width(inner_width);
ui.set_max_width(inner_width);
ui.set_min_height(inner_height);
draw_force_chart_panel_contents(ui, code, title, values, inner_height);
});
});
}
@@ -969,7 +1130,7 @@ fn draw_force_chart_panel_contents(
});
ui.add_space(6.0);
let chart_height = (content_height - 32.0).max(90.0);
let chart_height = (content_height - 32.0).max(36.0);
paint_resultant_force_chart(ui, values, chart_height);
}
@@ -977,7 +1138,7 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
const CHART_POINTS: usize = 42;
const CHART_WINDOW_SECONDS: f32 = CHART_POINTS as f32 * FORCE_CHART_SAMPLE_SECONDS;
let width = ui.available_width().max(180.0);
let width = ui.available_width().max(80.0);
let (rect, _) = ui.allocate_exact_size(egui::vec2(width, chart_height), egui::Sense::hover());
let painter = ui.painter_at(rect);
let radius = egui::CornerRadius::same(5);
@@ -1015,9 +1176,7 @@ fn paint_resultant_force_chart(ui: &mut egui::Ui, values: &[f32], chart_height:
.ctx()
.animate_bool(egui::Id::new("resultant_force_chart_enter"), true);
let slide_offset = (1.0 - enter) * -chart_rect.width() * 0.65;
let tick_phase = (time / FORCE_CHART_SAMPLE_SECONDS).fract();
let scroll_offset = -tick_phase * chart_rect.width() / CHART_POINTS.max(1) as f32;
let plot_rect = chart_rect.translate(egui::vec2(slide_offset + scroll_offset, 0.0));
let plot_rect = chart_rect.translate(egui::vec2(slide_offset, 0.0));
let mut points = Vec::with_capacity(values.len());
let start_slot = CHART_POINTS.saturating_sub(values.len());
@@ -1144,6 +1303,132 @@ fn color_alpha(color: egui::Color32, alpha: u8) -> egui::Color32 {
egui::Color32::from_rgba_premultiplied(color.r(), color.g(), color.b(), alpha)
}
fn faded_panel_frame(ctx: &egui::Context, alpha: u8) -> egui::Frame {
let style = ctx.global_style();
egui::Frame::window(&style)
.fill(color_alpha(ONE_DARK_PRO.panel, alpha))
.stroke(egui::Stroke::new(
1.0,
color_alpha(ONE_DARK_PRO.border, alpha),
))
.corner_radius(egui::CornerRadius::same(ONE_DARK_PRO.radius))
.inner_margin(egui::Margin::same(METRICS.panel_padding))
.shadow(egui::epaint::Shadow {
offset: [0, 14],
blur: 28,
spread: 0,
color: egui::Color32::from_black_alpha((alpha as f32 * 0.45) as u8),
})
}
fn paint_spatial_force_gauge(
painter: &egui::Painter,
rect: egui::Rect,
force: HudSpatialForce,
alpha: u8,
) {
let center = rect.center();
let radius = rect.width().min(rect.height()) * 0.42;
let angle = force.angle_deg.to_radians();
let direction = egui::vec2(angle.cos(), angle.sin());
let magnitude = force.magnitude.clamp(0.0, 1.0);
let end = center + direction * (radius * (0.35 + magnitude * 0.65));
let side = egui::vec2(-direction.y, direction.x);
painter.circle_stroke(
center,
radius,
egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border, alpha)),
);
painter.circle_stroke(
center,
radius * 0.55,
egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 2)),
);
painter.line_segment(
[
center + egui::vec2(-radius, 0.0),
center + egui::vec2(radius, 0.0),
],
egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 3)),
);
painter.line_segment(
[
center + egui::vec2(0.0, -radius),
center + egui::vec2(0.0, radius),
],
egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border_soft, alpha / 3)),
);
painter.circle_filled(
end,
12.0,
color_alpha(ACCENT_ORANGE, (alpha as f32 * 0.16) as u8),
);
painter.line_segment(
[center, end],
egui::Stroke::new(4.0, color_alpha(ACCENT_ORANGE, alpha)),
);
painter.line_segment(
[end, end - direction * 13.0 + side * 7.0],
egui::Stroke::new(3.0, color_alpha(ACCENT_ORANGE, alpha)),
);
painter.line_segment(
[end, end - direction * 13.0 - side * 7.0],
egui::Stroke::new(3.0, color_alpha(ACCENT_ORANGE, alpha)),
);
painter.circle_filled(center, 4.5, color_alpha(ONE_DARK_PRO.text_dim, alpha));
painter.circle_filled(end, 5.5, color_alpha(ACCENT_GREEN, alpha));
painter.circle_filled(end, 2.2, color_alpha(egui::Color32::WHITE, alpha));
}
fn draw_pinned_panel(
ctx: &egui::Context,
_panel: &mut FloatingPanelState,
title: &'static str,
id: &'static str,
preferred_width: f32,
min_width: f32,
add_contents: impl FnOnce(&mut egui::Ui),
) {
let panel_width = responsive_panel_width(ctx, preferred_width, min_width);
let max_height = responsive_panel_height(ctx, ctx.content_rect().height(), 180.0);
let viewport = viewport_panel_rect(ctx);
let x = (viewport.center().x - panel_width * 0.5).clamp(
viewport.left(),
(viewport.right() - panel_width).max(viewport.left()),
);
let y = viewport.top() + layout::TITLE_BAR_HEIGHT + PANEL_VIEWPORT_MARGIN;
let pos = egui::pos2(x, y);
egui::Window::new(title)
.id(egui::Id::new(id))
.current_pos(pos)
.max_width(panel_width)
.max_height(max_height)
.constrain_to(viewport_panel_rect(ctx))
.title_bar(false)
.resizable(false)
.frame(panel_frame(ctx))
.show(ctx, |ui| {
ui.spacing_mut().item_spacing = egui::vec2(METRICS.item_gap, 6.0);
ui.set_min_width(panel_width);
ui.set_max_width(panel_width);
ui.horizontal(|ui| {
ui.label(style::panel_title(title));
});
ui.separator();
let content_max_height = (max_height - 60.0).max(120.0);
egui::ScrollArea::vertical()
.max_height(content_max_height)
.auto_shrink([false, true])
.show(ui, |ui| {
ui.set_min_width(panel_width);
ui.set_max_width(panel_width);
add_contents(ui);
});
});
}
fn draw_floating_panel(
ctx: &egui::Context,
panel: &mut FloatingPanelState,

237
static/wgsl/shader.wgsl
View File

@@ -63,7 +63,7 @@ fn linear_to_srgb(linear: vec3f) -> vec3f {
fn output_color(linear_rgb: vec3f, alpha: f32) -> vec4f {
let clamped = clamp(linear_rgb, vec3f(0.0), vec3f(1.0));
if (u.color.w > 0.5) {
if u.color.w > 0.5 {
return vec4f(clamped, alpha);
}
@@ -91,12 +91,12 @@ fn range_stop_color(index: u32) -> vec3f {
fn sample_range_color(value: f32) -> vec3f {
let t = saturate(value);
if (t <= 0.33) {
if t <= 0.33 {
let local = smoothstep(0.0, 0.33, t);
return mix(range_stop_color(0u), range_stop_color(1u), local);
}
if (t <= 0.66) {
if t <= 0.66 {
let local = smoothstep(0.33, 0.66, t);
return mix(range_stop_color(1u), range_stop_color(2u), local);
}
@@ -105,7 +105,6 @@ fn sample_range_color(value: f32) -> vec3f {
return mix(range_stop_color(2u), range_stop_color(3u), local);
}
// background
struct BackgroundVertexOutput {
@builtin(position) clip_position: vec4f,
@@ -129,7 +128,6 @@ fn fs_background(@builtin(position) frag_coord: vec4f) -> @location(0) vec4f {
return output_color(vec3f(0.0, 0.0, 0.0), 1.0);
}
// hand image background
struct HandImageVertexOutput {
@builtin(position) clip_position: vec4f,
@@ -167,7 +165,7 @@ fn fs_hand_image(in: HandImageVertexOutput) -> @location(0) vec4f {
let image_aspect = u.image.x / max(u.image.y, 1.0);
var uv = in.screen_uv;
if (viewport_aspect > image_aspect) {
if viewport_aspect > image_aspect {
let image_width = image_aspect / viewport_aspect;
uv.x = (uv.x - (1.0 - image_width) * 0.5) / image_width;
} else {
@@ -175,7 +173,7 @@ fn fs_hand_image(in: HandImageVertexOutput) -> @location(0) vec4f {
uv.y = (uv.y - (1.0 - image_height) * 0.5) / image_height;
}
if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
if uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 {
discard;
}
@@ -183,7 +181,6 @@ fn fs_hand_image(in: HandImageVertexOutput) -> @location(0) vec4f {
return output_color(color.rgb, color.a);
}
// glyph
struct GlyphVertexInput {
@location(0) local: vec2f,
@@ -226,45 +223,45 @@ fn digit_segment_on(digit: u32, segment: u32) -> bool {
fn seven_segment_digit_alpha(local: vec2f, digit: u32) -> f32 {
var alpha = 0.0;
if (digit_segment_on(digit, 0u)) {
if digit_segment_on(digit, 0u) {
alpha = max(alpha, rect_alpha(local, vec2f(0.0, 0.70), vec2f(0.38, 0.078)));
}
if (digit_segment_on(digit, 1u)) {
if digit_segment_on(digit, 1u) {
alpha = max(alpha, rect_alpha(local, vec2f(0.39, 0.36), vec2f(0.078, 0.335)));
}
if (digit_segment_on(digit, 2u)) {
if digit_segment_on(digit, 2u) {
alpha = max(alpha, rect_alpha(local, vec2f(0.39, -0.36), vec2f(0.078, 0.335)));
}
if (digit_segment_on(digit, 3u)) {
if digit_segment_on(digit, 3u) {
alpha = max(alpha, rect_alpha(local, vec2f(0.0, -0.70), vec2f(0.38, 0.078)));
}
if (digit_segment_on(digit, 4u)) {
if digit_segment_on(digit, 4u) {
alpha = max(alpha, rect_alpha(local, vec2f(-0.39, -0.36), vec2f(0.078, 0.335)));
}
if (digit_segment_on(digit, 5u)) {
if digit_segment_on(digit, 5u) {
alpha = max(alpha, rect_alpha(local, vec2f(-0.39, 0.36), vec2f(0.078, 0.335)));
}
if (digit_segment_on(digit, 6u)) {
if digit_segment_on(digit, 6u) {
alpha = max(alpha, rect_alpha(local, vec2f(0.0, 0.0), vec2f(0.35, 0.075)));
}
return alpha;
}
fn digit_count(value: u32) -> u32 {
if (value >= 1000u) {
if value >= 1000u {
return 4u;
}
if (value >= 100u) {
if value >= 100u {
return 3u;
}
if (value >= 10u) {
if value >= 10u {
return 2u;
}
return 1u;
}
fn digit_at(value: u32, slot: u32, count: u32) -> u32 {
if (count == 4u) {
if count == 4u {
switch slot {
case 0u: { return (value / 1000u) % 10u; }
case 1u: { return (value / 100u) % 10u; }
@@ -272,14 +269,14 @@ fn digit_at(value: u32, slot: u32, count: u32) -> u32 {
default: { return value % 10u; }
}
}
if (count == 3u) {
if count == 3u {
switch slot {
case 0u: { return (value / 100u) % 10u; }
case 1u: { return (value / 10u) % 10u; }
default: { return value % 10u; }
}
}
if (count == 2u) {
if count == 2u {
return select(value % 10u, (value / 10u) % 10u, slot == 0u);
}
return value % 10u;
@@ -294,7 +291,7 @@ fn number_alpha(local: vec2f, display_value: f32) -> f32 {
var alpha = 0.0;
for (var slot = 0u; slot < 4u; slot = slot + 1u) {
if (slot < count) {
if slot < count {
let center_x = start_x + f32(slot) * slot_width;
let digit_local = vec2f((local.x - center_x) / (slot_width * 0.78), local.y / 0.92);
let digit = digit_at(value, slot, count);
@@ -335,8 +332,7 @@ struct DotVertexInput {
struct DotInstanceInput {
@location(1) world_position: vec4f,
@location(2) style: vec4f
}
@location(2) style: vec4f}
struct DotVertexOutput {
@builtin(position) clip_position: vec4f,
@@ -358,7 +354,7 @@ fn hand_image_uv_to_clip(image_uv: vec2f) -> vec2f {
var screen_uv = image_uv;
if (viewport_aspect > image_aspect) {
if viewport_aspect > image_aspect {
let image_width = image_aspect / viewport_aspect;
screen_uv.x = image_uv.x * image_width + (1.0 - image_width) * 0.5;
} else {
@@ -386,12 +382,15 @@ fn rounded_rect_alpha(local: vec2f, radius: f32, softness: f32) -> f32 {
return 1.0 - smoothstep(0.0, softness, dist);
}
fn dot_matrix(uv: vec2f, grid: vec2f, dot_radius: f32, dot_softness: f32) -> f32 {
let cell = fract(uv * grid) - vec2f(0.5, 0.5);
return 1.0 - smoothstep(dot_radius, dot_radius + dot_softness, length(cell));
}
fn fingertip_film_alpha(
local: vec2f,
half_width: f32,
cap_center_y: f32,
rear_edge_y: f32,
rear_bulge: f32,
softness: f32,
) -> f32 {
// Top/front of the film is a closed round fingertip cap.
@@ -399,14 +398,10 @@ fn fingertip_film_alpha(
let cap = (1.0 - smoothstep(half_width, half_width + softness, cap_dist))
* (1.0 - smoothstep(cap_center_y - softness, cap_center_y + softness, local.y));
// The rear half keeps nearly parallel sides and ends with a shallow arc;
// it deliberately does not converge back into another capsule end.
let x_norm = clamp(abs(local.x) / max(half_width, 0.001), 0.0, 1.0);
let rear_curve_y = rear_edge_y + rear_bulge * (1.0 - x_norm * x_norm);
// The rear remains open; the carrier quad clips the membrane at its end.
let side = 1.0 - smoothstep(half_width, half_width + softness, abs(local.x));
let rear = 1.0 - smoothstep(rear_curve_y, rear_curve_y + softness, local.y);
let body_gate = smoothstep(cap_center_y - softness, cap_center_y + softness, local.y);
let body = side * rear * body_gate;
let body = side * body_gate;
return max(cap, body);
}
@@ -427,38 +422,93 @@ fn vs_hand_membrane(vertex: DotVertexInput, instance: DotInstanceInput) -> HandM
@fragment
fn fs_hand_membrane(in: HandMembraneVertexOutput) -> @location(0) vec4f {
// The film shape matches the fingertip: closed round front, parallel rear sides,
// and a shallow rear arc instead of a second capsule end.
let panel = fingertip_film_alpha(in.local, 0.66, -0.38, 0.72, 0.18, 0.045);
let inner = fingertip_film_alpha(in.local, 0.54, -0.36, 0.64, 0.12, 0.060);
let border = clamp(panel - inner * 0.52, 0.0, 1.0);
let p = in.local;
// Dense mesh: the live 12x7 pressure dots sit over this finer sensor lattice.
let uv = clamp(in.local * 0.5 + vec2f(0.5, 0.5), vec2f(0.0, 0.0), vec2f(1.0, 1.0));
let grid = vec2f(18.0, 34.0);
let cell = uv * grid - vec2f(0.5, 0.5);
let nearest = abs(fract(cell + vec2f(0.5, 0.5)) - vec2f(0.5, 0.5));
let grid_line = max(
1.0 - smoothstep(0.014, 0.038, nearest.x),
1.0 - smoothstep(0.014, 0.038, nearest.y),
let halo_shape = fingertip_film_alpha(p, 0.72, -0.20, 0.055);
let panel = fingertip_film_alpha(p, 0.66, -0.22, 0.035);
let inner = fingertip_film_alpha(p, 0.58, -0.25, 0.045);
let clear_inner = fingertip_film_alpha(p, 0.48, -0.24, 0.160);
let halo = clamp(halo_shape - panel, 0.0, 1.0);
let rim = clamp(panel - inner, 0.0, 1.0);
let edge_fade = pow(clamp(1.0 - clear_inner, 0.0, 1.0), 1.20) * panel;
// Strong pseudo extrusion / bevel.
let depth_offset = vec2f(0.045, 0.055);
let back_shape_1 = fingertip_film_alpha(p - depth_offset * 0.55, 0.66, -0.22, 0.045);
let back_shape_2 = fingertip_film_alpha(p - depth_offset, 0.66, -0.22, 0.060);
let extrusion = clamp(max(back_shape_1, back_shape_2) - panel, 0.0, 1.0);
let bevel_offset = vec2f(0.028, 0.034);
let shifted_down_right = fingertip_film_alpha(p - bevel_offset, 0.66, -0.22, 0.035);
let bevel_light = clamp(panel - shifted_down_right, 0.0, 1.0);
let shifted_up_left = fingertip_film_alpha(p + bevel_offset, 0.66, -0.22, 0.035);
let bevel_dark = clamp(panel - shifted_up_left, 0.0, 1.0);
let broad_bevel = edge_fade * clamp(0.58 - p.x * 0.20 - p.y * 0.18, 0.0, 1.0);
// Micro lattice.
let uv = clamp(
p * vec2f(0.52, 0.46) + vec2f(0.5, 0.46),
vec2f(0.0, 0.0),
vec2f(1.0, 1.0),
);
let joint = 1.0 - smoothstep(0.070, 0.150, length(nearest * vec2f(1.18, 1.0)));
let center_shadow = 1.0 - smoothstep(0.10, 0.76, length(in.local * vec2f(0.92, 0.66)));
let top_light = smoothstep(-0.52, 0.16, -in.local.y) * 0.20;
let side_glow = smoothstep(0.30, 0.70, abs(in.local.x)) * 0.26;
let lift_shadow = smoothstep(0.48, 0.86, in.local.y) * (1.0 - smoothstep(0.50, 0.86, abs(in.local.x))) * 0.13;
let scan = (0.5 + 0.5 * sin((uv.y * 76.0 + uv.x * 9.0) * 6.28318)) * 0.030;
let grid = vec2f(18.0, 34.0);
let cell_uv = fract(uv * grid) - vec2f(0.5, 0.5);
let dot_dist = length(cell_uv * vec2f(1.0, 1.06));
let dot_aa = max(fwidth(dot_dist) * 1.35, 0.006);
let dots = (1.0 - smoothstep(0.105 - dot_aa, 0.105 + dot_aa, dot_dist)) * inner;
let membrane_color = vec3f(0.006, 0.28, 0.38);
let line_color = vec3f(0.12, 0.72, 0.88);
let rim_color = vec3f(0.18, 0.98, 1.0);
let color = membrane_color * (0.68 + top_light + side_glow + scan)
+ line_color * (grid_line * 0.20 + joint * 0.42)
+ rim_color * (border * 0.92 + side_glow * 0.18)
- vec3f(0.0, 0.16, 0.24) * center_shadow * 0.30
- vec3f(0.0, 0.10, 0.16) * lift_shadow;
let alpha = panel * (0.24 + grid_line * 0.10 + joint * 0.23 + border * 0.42);
let sheen_axis = p.x * 0.88 + p.y * 0.22 + 0.16;
let sheen = (1.0 - smoothstep(0.018, 0.105, abs(sheen_axis))) * panel;
let shell_sheen = sheen * (0.26 + edge_fade * 0.74);
// Temporary synthetic pressure hotspot. Real hand pressure dots are drawn above this pass.
let pressure_center = vec2f(-0.08, -0.12);
let pressure_dist = length((p - pressure_center) * vec2f(1.0, 0.74));
let pressure = (1.0 - smoothstep(0.05, 0.36, pressure_dist)) * inner;
let pressure_hot = (1.0 - smoothstep(0.02, 0.13, pressure_dist)) * inner;
let glass_base = vec3f(0.006, 0.055, 0.105);
let glass_cyan = vec3f(0.025, 0.42, 0.58);
let rim_color = vec3f(0.10, 0.88, 1.00);
let extrusion_color = vec3f(0.004, 0.080, 0.110);
let extrusion_edge_color = vec3f(0.015, 0.30, 0.38);
let bevel_highlight = vec3f(0.48, 1.00, 1.00);
let bevel_dark_color = vec3f(0.004, 0.035, 0.060);
let dot_color = vec3f(0.08, 0.48, 0.58);
let pressure_color = dot_color;
let pressure_hot_color = dot_color;
let color = extrusion_color * extrusion * 0.90
+ extrusion_edge_color * extrusion * halo_shape * 0.32
+ glass_base * panel * 0.26
+ glass_cyan * edge_fade * 0.46
+ glass_cyan * broad_bevel * 0.24
+ rim_color * rim * 0.88
+ bevel_highlight * bevel_light * 1.35
+ bevel_dark_color * bevel_dark * 0.95
+ bevel_highlight * shell_sheen * 0.28
+ rim_color * halo * 0.16
+ dot_color * dots * 0.68
+ pressure_color * dots * pressure * 0.82
+ pressure_hot_color * dots * pressure_hot * 0.90;
let alpha = clamp(
extrusion * 0.44
+ panel * 0.055
+ edge_fade * 0.30
+ rim * 0.34
+ bevel_light * 0.34
+ bevel_dark * 0.20
+ shell_sheen * 0.09
+ halo * 0.045
+ dots * 0.09
+ dots * pressure * 0.10,
0.0,
0.90,
);
return output_color(color, alpha);
}
@@ -532,33 +582,9 @@ fn vs_hand_palm_chip(vertex: DotVertexInput, instance: DotInstanceInput) -> Hand
@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);
// The live palm-dot pass draws every chip cell, including the idle dots.
// Keeping this background pass transparent prevents a second offset dot grid.
return output_color(vec3f(0.0, 0.0, 0.0), 0.0);
}
@vertex
@@ -566,9 +592,8 @@ fn vs_hand_palm_dot(vertex: DotVertexInput, instance: DotInstanceInput) -> DotVe
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);
let pixel_size = u.glyph.x * mix(0.22, 0.34, shaped);
let ndc_offset = vertex.local * vec2f(pixel_size / u.viewport.x, pixel_size / u.viewport.y) * 2.0;
var out: DotVertexOutput;
@@ -581,17 +606,16 @@ fn vs_hand_palm_dot(vertex: DotVertexInput, instance: DotInstanceInput) -> DotVe
@fragment
fn fs_hand_palm_dot(in: DotVertexOutput) -> @location(0) vec4f {
let intensity = saturate(in.intensity);
let pixel = chip_pixel_alpha(in.local, 0.52, 0.070);
let glow = circle_alpha(in.local, 0.95, 0.22) * intensity * 0.36;
let cold = vec3f(0.070, 0.340, 0.360);
let core = circle_alpha(in.local, 0.48, 0.07);
let halo = circle_alpha(in.local, 0.74, 0.14) * (0.10 + intensity * 0.26);
let idle = vec3f(0.060, 0.250, 0.320);
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 color = mix(idle, gradient, smoothstep(0.0, 0.18, intensity))
* mix(0.78, 1.18, intensity);
let alpha = max(pixel * (0.20 + intensity * 0.76), glow);
return output_color(color, alpha);
return output_color(color, max(core, halo));
}
@vertex
@@ -621,7 +645,6 @@ fn fs_dot(in: DotVertexOutput) -> @location(0) vec4f {
return output_color(color, alpha);
}
// model
struct ModelVertexInput {
@location(0) position: vec3f,
@@ -740,11 +763,11 @@ fn aces_tonemap(x: vec3f) -> vec3f {
fn material_normal(in: ModelVertexOutput, front_facing: bool) -> vec3f {
var n = normalize(in.world_normal);
if (!front_facing && material.flags.w > 0.5) {
if !front_facing && material.flags.w > 0.5 {
n = -n;
}
if (material.flags.z < 0.5) {
if material.flags.z < 0.5 {
return n;
}
@@ -764,17 +787,17 @@ fn fs_model(in: ModelVertexOutput, @builtin(front_facing) front_facing: bool) ->
let base_color = base_sample * material.base_color * in.color;
let alpha_mode = material.emissive_alpha.w;
var alpha = base_color.a;
if (alpha_mode < 0.5) {
if alpha_mode < 0.5 {
alpha = 1.0;
} else if (alpha_mode < 1.5) {
if (alpha < material.flags.x) {
} else if alpha_mode < 1.5 {
if alpha < material.flags.x {
discard;
}
alpha = 1.0;
}
let debug_mode = u32(u.render_options.x + 0.5);
if (debug_mode == 1u) {
if debug_mode == 1u {
return output_color(base_color.rgb, alpha);
}
@@ -840,7 +863,7 @@ fn fs_model(in: ModelVertexOutput, @builtin(front_facing) front_facing: bool) ->
let ambient_strength = 0.08;
// Temporary neutral linear ambient term until a real IBL/HDR environment is added.
var ambient = vec3f(0.0);
if (u.render_options.y > 0.5) {
if u.render_options.y > 0.5 {
let ambient_diffuse = albedo * (1.0 - metallic) * ambient_color * ambient_strength;
let ambient_specular = f_ambient * ambient_color * ambient_strength * (1.0 - roughness * 0.55);
ambient = (ambient_diffuse + ambient_specular) * ao;
@@ -848,7 +871,7 @@ fn fs_model(in: ModelVertexOutput, @builtin(front_facing) front_facing: bool) ->
let exposed_color = (ambient + key + fill + emissive) * max(u.render_options.w, 0.0);
var color = exposed_color;
if (u.render_options.z > 0.5) {
if u.render_options.z > 0.5 {
color = aces_tonemap(exposed_color);
}