Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
//! Piste curseur depuis un `.cursor.json` openscreen. Fournit position interpolée
//! et facteur de « click bounce » — consommés par frame (temps fractionnaire), donc
//! le motion blur du curseur vient gratuitement du supersampling temporel.
use anyhow::{Context, Result};
// Paramètres de suivi auto — parité stricte avec
// `src/lib/zoomMath/constants.ts` (AUTO_FOLLOW_PARAMS), partagés
// là-bas entre preview et export pour que la caméra suive le curseur à l'identique.
const AUTO_FOLLOW_MIN_FACTOR: f32 = 0.1;
const AUTO_FOLLOW_MAX_FACTOR: f32 = 0.25;
const AUTO_FOLLOW_RAMP_DISTANCE: f32 = 0.15;
const AUTO_FOLLOW_REFERENCE_MS: f32 = 1000.0 / 40.0;
/// Part de la vue zoomée, par axe, où le pointeur bouge sans que la vue le suive : sa moitié
/// centrale (`follow_in_view`). Au-delà, la vue le rattrape juste assez pour le ramener au bord de
/// cette zone. Sans elle, la vue suivait chaque petit geste et le cadrage paraissait nerveux.
const FOLLOW_DEAD_ZONE: f32 = 0.5;
// Convergence du curseur dessiné sur le point cliqué (`pinned_at`). L'approche accompagne la
// plongée du curseur modélisé, et la tenue couvre son appui (du clic à 80 ms après).
const PIN_APPROACH_S: f32 = 0.25;
const PIN_HOLD_S: f32 = 0.1;
const PIN_RELEASE_S: f32 = 0.25;
fn smoothstep01(x: f32) -> f32 {
let u = x.clamp(0.0, 1.0);
u * u * (3.0 - 2.0 * u)
}
#[derive(Clone)]
pub struct CursorTrack {
/// (t_secondes, cx, cy) normalisés dans le cadre screen, triés.
samples: Vec<(f32, f32, f32)>,
/// Même piste après lissage exponentiel adaptatif — ce que le suivi auto du zoom doit
/// consommer. `samples` reste la piste BRUTE : le rendu du curseur lui-même et le click
/// bounce doivent coller à la position réelle, seule la caméra est amortie.
follow_samples: Vec<(f32, f32, f32)>,
/// instants de clic (secondes) dans la fenêtre.
clicks: Vec<f32>,
/// Position BRUTE de chaque clic (même ordre que `clicks`) : le pixel où l'utilisateur a
/// réellement cliqué. `smoothed()` la garde telle quelle, alors que la piste lissée passe
/// ailleurs à cet instant (cf. `pinned_at`).
click_points: Vec<(f32, f32)>,
/// CHANGEMENTS de visibilité : `(instant, visible)`, triés. Comme `types`, c'est une
/// fonction en escalier. Une piste ancienne sans champ `visible` reste visible.
visibility: Vec<(f32, bool)>,
/// CHANGEMENTS d'état du curseur : (instant, `"arrow"` / `"text"` / `"pointer"` / …), triés.
/// Une fonction en escalier, pas une valeur par échantillon : l'état tient sur des secondes
/// entières alors que la position est échantillonnée toutes les 33 ms (~30 Hz, cf.
/// `CURSOR_SAMPLE_INTERVAL_MS` côté Electron), donc n'enregistrer que les
/// transitions garde cette liste minuscule et rend `type_at` trivial.
types: Vec<(f32, String)>,
/// Les vues du suivi à zone morte déjà rejouées, par `(t0, fin, échelle)` : une par région auto
/// (`follow_in_view`). Partagé entre clones, qui ont les mêmes échantillons.
view_cache:
std::sync::Arc<std::sync::Mutex<Vec<(ViewKey, std::sync::Arc<Vec<(f32, f32, f32)>>)>>>,
}
type ViewKey = (u32, u32, u32);
/// Assez pour toutes les régions auto d'un clip ; au-delà, la plus ancienne est rejouée.
const VIEW_CACHE_LEN: usize = 32;
/// Interpolation linéaire dans une liste `(t, x, y)` triée ; saturation aux bornes.
fn sample_at(samples: &[(f32, f32, f32)], t: f32) -> Option<(f32, f32)> {
if samples.is_empty() {
return None;
}
if t <= samples[0].0 {
let s = samples[0];
return Some((s.1, s.2));
}
if t >= samples[samples.len() - 1].0 {
let s = *samples.last().unwrap();
return Some((s.1, s.2));
}
// recherche du segment encadrant
let i = samples.partition_point(|s| s.0 <= t);
let a = samples[i - 1];
let b = samples[i];
let f = if b.0 > a.0 {
(t - a.0) / (b.0 - a.0)
} else {
0.0
};
Some((a.1 + (b.1 - a.1) * f, a.2 + (b.2 - a.2) * f))
}
/// Port de `advanceFollowFocus` (`cursorFollowUtils.ts`) : lissage exponentiel dont le facteur
/// croît avec la distance à la cible (loin = rattrape vite, près = décélère), corrigé en temps
/// pour être indépendant de la cadence.
///
/// La version TS est **séquentielle** : elle avance un `prev` d'une frame à l'autre. Rejouer ça
/// par frame ici ferait dépendre l'image du chemin parcouru pour l'atteindre — deux rendus du
/// même instant divergeraient selon qu'on y arrive en lecture ou par un seek, et la preview ne
/// correspondrait plus à l'export. On applique donc le même filtre UNE fois, sur les
/// échantillons de télémétrie eux-mêmes : le résultat est identique en lecture linéaire et reste
/// une pure fonction de `t`.
fn smooth_follow_samples(samples: &[(f32, f32, f32)]) -> Vec<(f32, f32, f32)> {
let mut smoothed: Vec<(f32, f32, f32)> = Vec::with_capacity(samples.len());
let mut prev: Option<(f32, f32, f32)> = None;
for &(t, x, y) in samples {
let Some((prev_t, px, py)) = prev else {
smoothed.push((t, x, y));
prev = Some((t, x, y));
continue;
};
let dt_ms = (t - prev_t) * 1000.0;
if !(dt_ms > 0.0) {
// Horodatages dupliqués : on garde la valeur déjà lissée plutôt que de diviser par 0.
smoothed.push((t, px, py));
prev = Some((t, px, py));
continue;
}
let (nx, ny) = follow_step((px, py), (x, y), dt_ms);
smoothed.push((t, nx, ny));
prev = Some((t, nx, ny));
}
smoothed
}
/// Un pas du lissage de suivi : `from` avance vers `to` d'un facteur qui croît avec la distance
/// (loin = rattrape vite, près = décélère), corrigé en temps sur `dt_ms`.
fn follow_step(from: (f32, f32), to: (f32, f32), dt_ms: f32) -> (f32, f32) {
let (dx, dy) = (to.0 - from.0, to.1 - from.1);
let distance = (dx * dx + dy * dy).sqrt();
let ramp = (distance / AUTO_FOLLOW_RAMP_DISTANCE).min(1.0);
let base = AUTO_FOLLOW_MIN_FACTOR + (AUTO_FOLLOW_MAX_FACTOR - AUTO_FOLLOW_MIN_FACTOR) * ramp;
let factor = 1.0 - (1.0 - base).powf(dt_ms / AUTO_FOLLOW_REFERENCE_MS);
(from.0 + dx * factor, from.1 + dy * factor)
}
impl CursorTrack {
/// Seul point de construction : garantit que `follow_samples` est toujours dérivé des
/// échantillons courants. Une piste re-lissée (`smoothed`) recalcule donc aussi son suivi,
/// pour que la caméra suive la trajectoire que l'utilisateur voit réellement.
pub(crate) fn new(
samples: Vec<(f32, f32, f32)>,
clicks: Vec<f32>,
types: Vec<(f32, String)>,
) -> CursorTrack {
CursorTrack::new_with_visibility(samples, clicks, types, Vec::new())
}
pub(crate) fn new_with_visibility(
samples: Vec<(f32, f32, f32)>,
clicks: Vec<f32>,
types: Vec<(f32, String)>,
visibility: Vec<(f32, bool)>,
) -> CursorTrack {
let follow_samples = smooth_follow_samples(&samples);
let click_points = clicks
.iter()
.map(|&tc| sample_at(&samples, tc).unwrap_or((0.0, 0.0)))
.collect();
CursorTrack {
samples,
follow_samples,
clicks,
click_points,
visibility,
types,
view_cache: Default::default(),
}
}
/// Visibilité enregistrée au temps `t`. Les anciens sidecars qui n'ont pas ce champ sont
/// visibles par défaut, comme les lecteurs TypeScript.
pub fn visible_at(&self, t: f32) -> bool {
let i = self.visibility.partition_point(|(tc, _)| *tc <= t);
if i == 0 {
true
} else {
self.visibility[i - 1].1
}
}
/// État du curseur au temps `t` : la dernière transition à `t` ou avant. `None` avant la
/// première (enregistrement sans état tagué → l'appelant retombe sur la flèche).
pub fn type_at(&self, t: f32) -> Option<&str> {
let i = self.types.partition_point(|(tc, _)| *tc <= t);
(i > 0).then(|| self.types[i - 1].1.as_str())
}
/// Nombre d'échantillons de la piste (utile au diag de chargement).
pub fn sample_count(&self) -> usize {
self.samples.len()
}
/// Charge la fenêtre [offset_ms, offset_ms + dur_s*1000] et la ramène à t=0.
pub fn load(path: &str, offset_ms: f64, dur_s: f64) -> Result<CursorTrack> {
let txt = std::fs::read_to_string(path).with_context(|| format!("lecture {path}"))?;
let v: serde_json::Value = serde_json::from_str(&txt)?;
let arr = v["samples"].as_array().context("samples[]")?;
let mut samples = Vec::new();
let mut clicks = Vec::new();
let mut types: Vec<(f32, String)> = Vec::new();
let mut visibility_at_offset = true;
let mut visibility_sample_time = f64::NEG_INFINITY;
// A clipped track inherits the last recorded state at its source offset. Using the first
// later sample would reveal a cursor early when that sample is the transition to visible.
for s in arr {
let tm = s["timeMs"].as_f64().unwrap_or(-1.0);
if tm >= 0.0 && tm <= offset_ms && tm >= visibility_sample_time {
visibility_sample_time = tm;
visibility_at_offset = s
.get("visible")
.and_then(|value| value.as_bool())
.unwrap_or(true);
}
}
let mut visibility = vec![(0.0, visibility_at_offset)];
let end = offset_ms + dur_s * 1000.0;
for s in arr {
let tm = s["timeMs"].as_f64().unwrap_or(-1.0);
if tm < offset_ms || tm > end {
continue;
}
let t = ((tm - offset_ms) / 1000.0) as f32;
let cx = s["cx"].as_f64().unwrap_or(0.0) as f32;
let cy = s["cy"].as_f64().unwrap_or(0.0) as f32;
samples.push((t, cx, cy));
let visible = s
.get("visible")
.and_then(|value| value.as_bool())
.unwrap_or(true);
if visibility.last().map(|(_, previous)| *previous) != Some(visible) {
visibility.push((t, visible));
}
if visible && s["interactionType"].as_str() == Some("click") {
clicks.push(t);
}
// Seules les TRANSITIONS sont retenues — voir `types`. Le helper
// macOS rend nil hors texte/pointeur pour que le rendu retombe sur
// la flèche. Le sidecar stocke ça en JSON null ou omet la clé.
// Ignorer ces échantillons gardait le dernier type sémantique
// (`pointer`/`text`) : un thème restait collé après le retour à la
// flèche. Null / absence = reset vers `arrow`.
let ct = match s.get("cursorType") {
Some(v) => v
.as_str()
.filter(|label| !label.is_empty())
.unwrap_or("arrow"),
None => "arrow",
};
if types.last().map(|(_, prev)| prev.as_str()) != Some(ct) {
types.push((t, ct.to_string()));
}
}
samples.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
clicks.sort_by(|a, b| a.partial_cmp(b).unwrap());
types.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
visibility.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
Ok(CursorTrack::new_with_visibility(
samples, clicks, types, visibility,
))
}
/// Position lissée au temps `t`, pour le suivi auto du zoom. La télémétrie brute est
/// échantillonnée trop finement pour piloter une caméra directement : la suivre au sample
/// près donne un pan nerveux. Voir `smooth_follow_samples`.
pub fn follow_at(&self, t: f32) -> Option<(f32, f32)> {
sample_at(&self.follow_samples, t)
}
/// Le centre de la vue d'un zoom auto d'échelle `scale` à `t`, parti de `follow_at(t0)` en
/// `t0` : `follow_at` avec une zone morte. La vue ne bouge pas tant que le pointeur reste dans
/// la part `FOLLOW_DEAD_ZONE` de sa largeur autour de son centre ; il en sort, elle le
/// rattrape avec le même lissage, juste assez pour le ramener au bord de la zone. Bornée à ce
/// qu'une vue de `1/scale` peut atteindre, pour que la zone se mesure contre la vue affichée.
///
/// Rejouée depuis `t0` sur les échantillons BRUTS, puis mise en cache jusqu'à `t_end` : une
/// fonction pure de `(t0, t, t_end)`, donc la même en preview et à l'export, après un seek
/// comme en lecture. Le cache ne garde rien après la fenêtre de la région.
pub fn follow_in_view(&self, t0: f32, t: f32, t_end: f32, scale: f32) -> Option<(f32, f32)> {
let t_end = t_end.max(t0);
let t = t.clamp(t0, t_end);
let states = self.view_states(t0, t_end, scale)?;
let half = 0.5 / scale.max(1.0);
let reach = |v: f32| v.clamp(half, 1.0 - half);
// Après le dernier échantillon, la vue continue de rattraper le pointeur resté immobile
// jusqu'au bord de la zone, au lieu de se figer à mi-course.
let &(at, vx, vy) = states.last()?;
if t > at {
let (_, x, y) = *self.samples.last()?;
let dead = half * FOLLOW_DEAD_ZONE;
let pull = |cursor: f32, view: f32| cursor - (cursor - view).clamp(-dead, dead);
let (nx, ny) = follow_step((vx, vy), (pull(x, vx), pull(y, vy)), (t - at) * 1000.0);
return Some((reach(nx), reach(ny)));
}
if states.len() == 1 {
return Some((vx, vy));
}
// Entre deux états, linéaire, comme `follow_at`.
let i = states.partition_point(|s| s.0 < t).max(1);
let (a, b) = (states[i - 1], states[i]);
let f = if b.0 > a.0 {
((t - a.0) / (b.0 - a.0)).clamp(0.0, 1.0)
} else {
1.0
};
Some((a.1 + (b.1 - a.1) * f, a.2 + (b.2 - a.2) * f))
}
/// Les états `(t, x, y)` de `t0` à la fin de la fenêtre d'une région. Le dernier point est
/// interpolé à `t_end` si le curseur a encore des échantillons après cette fenêtre.
fn view_states(
&self,
t0: f32,
t_end: f32,
scale: f32,
) -> Option<std::sync::Arc<Vec<(f32, f32, f32)>>> {
let t_end = t_end.max(t0);
let key = (t0.to_bits(), t_end.to_bits(), scale.to_bits());
if let Some((_, v)) = self.view_cache.lock().ok()?.iter().find(|(k, _)| *k == key) {
return Some(v.clone());
}
let half = 0.5 / scale.max(1.0);
let dead = half * FOLLOW_DEAD_ZONE;
let reach = |v: f32| v.clamp(half, 1.0 - half);
// La cible : le point qui ramène le pointeur au bord de la zone, la vue elle-même dedans.
let pull = |cursor: f32, view: f32| cursor - (cursor - view).clamp(-dead, dead);
let (x0, y0) = self.follow_at(t0)?;
let mut view = (reach(x0), reach(y0));
let mut states = vec![(t0, view.0, view.1)];
let first = self.samples.partition_point(|s| s.0 <= t0);
let end = self.samples.partition_point(|s| s.0 <= t_end);
for &(ts, x, y) in &self.samples[first..end] {
let at = states.last().map_or(t0, |s| s.0);
let (nx, ny) =
follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);
view = (reach(nx), reach(ny));
states.push((ts, view.0, view.1));
}
let at = states.last().map_or(t0, |s| s.0);
if at < t_end {
if let Some(&(ts, x, y)) = self.samples.get(end) {
let (nx, ny) =
follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);
let f = ((t_end - at) / (ts - at)).clamp(0.0, 1.0);
states.push((
t_end,
view.0 + (nx - view.0) * f,
view.1 + (ny - view.1) * f,
));
}
}
let states = std::sync::Arc::new(states);
let mut cache = self.view_cache.lock().ok()?;
if cache.len() >= VIEW_CACHE_LEN {
cache.remove(0);
}
cache.push((key, states.clone()));
Some(states)
}
/// Position (cx, cy) au temps `t` (interpolation linéaire), ou None si hors piste. Brute, sauf
/// sur une piste `smoothed()`.
pub fn at(&self, t: f32) -> Option<(f32, f32)> {
sample_at(&self.samples, t)
}
/// `at(t)`, ramenée sur la position brute de chaque clic autour de lui : la pointe du curseur
/// modélisé doit toucher le pixel cliqué. Sur une piste lissée, le ressort traîne derrière la
/// souris et le contact tombait à côté de la cible ; sans lissage, la piste brute dérive pendant
/// le contact dès que la souris repart.
///
/// Pour chaque clic `tc`, un poids vers son point : il monte en smoothstep sur
/// `PIN_APPROACH_S`, vaut 1 sur `[tc, tc + PIN_HOLD_S]` (le contact), puis retombe en
/// smoothstep sur `PIN_RELEASE_S`. Les clics s'appliquent dans l'ordre, le plus récent
/// l'emporte. L'approche d'un clic ne commence qu'à la fin de la tenue du précédent : deux clics
/// rapprochés posent chacun la pointe sur leur point. Sous `2 * PIN_HOLD_S` d'écart, la tenue et
/// l'approche suivante se partagent l'écart à parts égales. Continue en `t` ; hors de ces
/// fenêtres, `at(t)` à l'identique.
pub fn pinned_at(&self, t: f32) -> Option<(f32, f32)> {
let (mut x, mut y) = self.at(t)?;
let lo = self
.clicks
.partition_point(|&tc| tc <= t - PIN_HOLD_S - PIN_RELEASE_S);
let hi = self.clicks.partition_point(|&tc| tc < t + PIN_APPROACH_S);
let hold = |i: usize| match self.clicks.get(i + 1) {
Some(&next) => ((next - self.clicks[i]) * 0.5).min(PIN_HOLD_S),
None => PIN_HOLD_S,
};
for i in lo..hi.max(lo) {
let d = t - self.clicks[i];
let w = if d < 0.0 {
let approach = match i.checked_sub(1) {
Some(p) => (self.clicks[i] - self.clicks[p] - hold(p)).clamp(1e-3, PIN_APPROACH_S),
None => PIN_APPROACH_S,
};
smoothstep01(1.0 + d / approach)
} else {
1.0 - smoothstep01((d - hold(i)) / PIN_RELEASE_S)
};
let (cx, cy) = self.click_points[i];
(x, y) = if w >= 1.0 {
(cx, cy)
} else {
(x + (cx - x) * w, y + (cy - y) * w)
};
}
Some((x, y))
}
/// Les clics de `(lo, hi]` avec leur position brute, triés.
pub fn clicks_with_points(
&self,
lo: f32,
hi: f32,
) -> impl Iterator<Item = (f32, (f32, f32))> + '_ {
let a = self.clicks.partition_point(|&tc| tc <= lo);
let b = self.clicks.partition_point(|&tc| tc <= hi).max(a);
self.clicks[a..b]
.iter()
.copied()
.zip(self.click_points[a..b].iter().copied())
}
/// Facteur d'échelle « click bounce ». Cette fonction est la SEULE référence de la courbe :
/// son ancien jumeau TS (`nativeCursor.ts`) a été supprimé avec pixi.js, et
/// `scripts/inspect-native-cursor-click-bounce.mjs` ne fait que la recopier. Le curseur
/// PRESSE (rétrécit jusqu'à 0.76, 0..38% de la fenêtre d'animation) PUIS REBONDIT (grossit
/// jusqu'à 1.16, 38..100%), pas un simple pop qui ne fait que grossir puis redécroître. Seul le clic le
/// plus récent précédant `t` compte (au-delà de la fenêtre, un clic antérieur n'a plus
/// aucun effet — contrairement à l'ancienne décroissance exponentielle à queue infinie qui
/// masquait ce bug). L'amplitude utilisateur (clickBounce) s'applique dans `plan_cursor`.
pub fn bounce(&self, t: f32) -> f32 {
const ANIM_S: f32 = 0.26; // 260 ms
const PRESS_FRAC: f32 = 0.38;
let Some(tc) = self.last_click_at(t) else {
return 1.0;
};
let elapsed = (t - tc) / ANIM_S;
if elapsed >= 1.0 {
return 1.0;
}
if elapsed < PRESS_FRAC {
let press = (elapsed / PRESS_FRAC * std::f32::consts::PI).sin();
1.0 - press * 0.24
} else {
let rebound =
((elapsed - PRESS_FRAC) / (1.0 - PRESS_FRAC) * std::f32::consts::PI).sin();
1.0 + rebound * 0.16
}
}
/// L'instant du dernier clic à `t` ou avant, `None` s'il n'y en a pas. C'est le point de
/// départ commun du rebond d'échelle (`bounce`) et de l'abaissement de la hauteur du curseur
/// modélisé — les deux doivent lire le MÊME contact, sinon le sprite s'écrase et se pose à
/// deux instants différents. Les clics sont triés croissant (voir `CursorTrack::new`).
pub(crate) fn last_click_at(&self, t: f32) -> Option<f32> {
let i = self.clicks.partition_point(|&tc| tc <= t);
if i == 0 {
return None;
}
Some(self.clicks[i - 1])
}
/// Les instants de clic dans `(lo, hi]`, triés. L'impact du clic sur le plan
/// (`regions::click_impact`) les somme tous, là où `bounce` ne garde que le dernier.
pub fn clicks_between(&self, lo: f32, hi: f32) -> &[f32] {
let a = self.clicks.partition_point(|&tc| tc <= lo);
let b = self.clicks.partition_point(|&tc| tc <= hi);
&self.clicks[a..b.max(a)]
}
/// Piste repositionnée par un ressort-amortisseur (parité `cursorPathSmoothing.ts` :
/// resample à 240 Hz + intégration semi-implicite d'Euler). `factor` 0..1 = valeur brute
/// du slider (0 = passthrough, retourne un clone). Les clics restent sur leurs instants
/// bruts (le bounce est temporel, pas positionnel — ne doit pas suivre le lissage).
pub fn smoothed(&self, factor: f32) -> CursorTrack {
if self.samples.len() < 2 || factor <= 0.0 {
return CursorTrack::new_with_visibility(
self.samples.clone(),
self.clicks.clone(),
self.types.clone(),
self.visibility.clone(),
);
}
const STEP_S: f32 = 1.0 / 240.0;
let start = self.samples[0].0;
let end = self.samples[self.samples.len() - 1].0;
let step_count = (((end - start) / STEP_S).round() as usize).max(1);
let n = step_count + 1;
let mut times = Vec::with_capacity(n);
let mut raw_x = Vec::with_capacity(n);
let mut raw_y = Vec::with_capacity(n);
for i in 0..n {
let t = if i == n - 1 {
end
} else {
start + i as f32 * STEP_S
};
let (cx, cy) = self.at(t).unwrap_or((0.0, 0.0));
times.push(t);
raw_x.push(cx);
raw_y.push(cy);
}
let (stiffness, damping, mass) = cursor_spring_config(factor);
// Une phase masquée coupe le ressort. Au retour, le curseur repart du premier point
// réellement visible au lieu de traverser la trajectoire cachée avec du retard.
let mut xs = Vec::with_capacity(n);
let mut ys = Vec::with_capacity(n);
let mut run_start = 0;
while run_start < n {
let visible = self.visible_at(times[run_start]);
let mut run_end = run_start + 1;
while run_end < n && self.visible_at(times[run_end]) == visible {
run_end += 1;
}
xs.extend(spring_smooth(
&raw_x[run_start..run_end],
stiffness,
damping,
mass,
STEP_S,
));
ys.extend(spring_smooth(
&raw_y[run_start..run_end],
stiffness,
damping,
mass,
STEP_S,
));
run_start = run_end;
}
let samples = times
.into_iter()
.zip(xs)
.zip(ys)
.map(|((t, x), y)| (t, x, y))
.collect();
// Comme les clics, les changements d'état gardent leurs instants bruts : le lissage
// déplace la trajectoire, pas la chronologie de ce que faisait l'utilisateur. Les points
// cliqués restent ceux de la piste brute.
CursorTrack {
click_points: self.click_points.clone(),
..CursorTrack::new_with_visibility(
samples,
self.clicks.clone(),
self.types.clone(),
self.visibility.clone(),
)
}
}
/// Opacité du curseur (0.0..1.0) selon l'inactivité (auto-hide).
/// Si `auto_hide` est faux, retourne toujours 1.0.
/// Si `auto_hide` est vrai :
/// - Le curseur reste à 1.0 tant qu'il bouge ou clique, et pendant 1.5s après le dernier mouvement/clic.
/// - Entre 1.5s et 1.8s d'inactivité, il s'estompe linéairement de 1.0 à 0.0 (fade-out 300ms).
/// - Au-delà de 1.8s, opacité 0.0.
pub fn opacity_at(&self, t: f32, auto_hide: bool) -> f32 {
if !auto_hide || self.samples.is_empty() {
return 1.0;
}
const IDLE_TIMEOUT_S: f32 = 1.5;
const FADE_DURATION_S: f32 = 0.3;
const MOVE_THRESH_SQ: f32 = 0.015 * 0.015;
let last_click = match self.clicks.partition_point(|&tc| tc <= t) {
0 => None,
i => Some(self.clicks[i - 1]),
};
let (cx, cy) = match self.at(t) {
Some(p) => p,
None => return 1.0,
};
let idx = self.samples.partition_point(|s| s.0 <= t);
let start_t = self.samples[0].0;
let mut arrival_t = if idx > 0 {
self.samples[idx - 1].0
} else {
start_t
};
if idx > 0 {
let mut i = idx - 1;
while i > 0 {
let prev = self.samples[i - 1];
let dx = cx - prev.1;
let dy = cy - prev.2;
if dx * dx + dy * dy > MOVE_THRESH_SQ {
arrival_t = self.samples[i].0;
break;
}
if t - prev.0 > IDLE_TIMEOUT_S + FADE_DURATION_S {
arrival_t = prev.0;
break;
}
i -= 1;
if i == 0 {
arrival_t = start_t;
}
}
}
if idx > 1 {
let s1 = self.samples[idx - 1];
let s0 = self.samples[idx - 2];
let d_step = (s1.1 - s0.1) * (s1.1 - s0.1) + (s1.2 - s0.2) * (s1.2 - s0.2);
if d_step > 0.005 * 0.005 && (t - s1.0).abs() < 0.1 {
arrival_t = t;
}
}
let mut last_activity = arrival_t;
if let Some(tc) = last_click {
if tc > last_activity {
last_activity = tc;
}
}
let idle_time = (t - last_activity).max(0.0);
if idle_time <= IDLE_TIMEOUT_S {
1.0
} else if idle_time >= IDLE_TIMEOUT_S + FADE_DURATION_S {
0.0
} else {
1.0 - (idle_time - IDLE_TIMEOUT_S) / FADE_DURATION_S
}
}
}
/// Ressort-amortisseur, intégration semi-implicite (symplectique) d'Euler — stable pour ces
/// raideurs à la grille 240 Hz (port direct de `springSmooth` en TS).
fn spring_smooth(
targets: &[f32],
stiffness: f32,
damping: f32,
mass: f32,
step_s: f32,
) -> Vec<f32> {
let mut out = vec![0.0f32; targets.len()];
if targets.is_empty() {
return out;
}
let mut x = targets[0];
let mut v = 0.0f32;
out[0] = x;
for i in 1..targets.len() {
let accel = (-stiffness * (x - targets[i]) - damping * v) / mass;
v += accel * step_s;
x += v * step_s;
out[i] = x;
}
out
}
/// Port direct de `getCursorSpringConfig` (TS) → (stiffness, damping, mass). N'accepte que
/// 0..1 (plage réelle du slider, cf. `RightPanes.tsx` : `smoothing * 100` sur un slider 0..100).
fn cursor_spring_config(smoothing_factor: f32) -> (f32, f32, f32) {
let clamped = smoothing_factor.clamp(0.0, 2.0);
if clamped <= 0.0 {
return (1000.0, 100.0, 1.0);
}
const LEGACY_MAX: f32 = 0.5;
if clamped <= LEGACY_MAX {
let n = (clamped / LEGACY_MAX).clamp(0.0, 1.0);
return (760.0 - n * 420.0, 34.0 + n * 24.0, 0.55 + n * 0.45);
}
let n = ((clamped - LEGACY_MAX) / (2.0 - LEGACY_MAX)).clamp(0.0, 1.0);
(340.0 - n * 180.0, 58.0 + n * 22.0, 1.0 + n * 0.35)
}
#[cfg(test)]
mod tests {
use super::*;
/// Zone morte du suivi auto : un pointeur qui tremble au centre de la vue ne la bouge pas ;
/// un pointeur qui part loin est rattrapé, jusqu'au bord de la zone et pas au-delà.
/// Les vues d'une région sont rejouées une fois puis relues : même réponse dans n'importe quel
/// ordre, et la même qu'une piste neuve qui les rejoue.
#[test]
fn the_cached_follow_view_answers_like_a_fresh_replay() {
let make = || {
CursorTrack::new(
(0..=150)
.map(|i| {
let t = i as f32 / 30.0;
(t, 0.5 + 0.3 * (t * 1.3).sin(), 0.5 + 0.2 * (t * 0.7).cos())
})
.collect(),
vec![],
vec![],
)
};
let (cached, times) = (make(), [4.9f32, 0.2, 3.3, 0.0, 2.71, 4.0]);
for t in times {
let _ = cached.follow_in_view(0.4, t, 5.0, 2.0);
}
for t in times {
assert_eq!(
cached.follow_in_view(0.4, t, 5.0, 2.0),
make().follow_in_view(0.4, t, 5.0, 2.0),
"t {t}"
);
}
// Une autre région (autre départ, autre échelle) a ses propres vues.
assert_ne!(
cached.follow_in_view(1.0, 3.0, 5.0, 3.0),
cached.follow_in_view(0.4, 3.0, 5.0, 2.0)
);
}
#[test]
fn the_follow_view_cache_stops_at_its_region_end() {
let track = CursorTrack::new(
(0..=300)
.map(|i| {
let t = i as f32 / 30.0;
(t, 0.5 + 0.2 * (t * 0.7).sin(), 0.5)
})
.collect(),
vec![],
vec![],
);
let at_end = track.follow_in_view(0.0, 2.0, 2.0, 2.0).unwrap();
assert_eq!(track.follow_in_view(0.0, 8.0, 2.0, 2.0), Some(at_end));
let cache = track.view_cache.lock().unwrap();
let states = &cache[0].1;
assert!(states.iter().all(|(t, _, _)| *t <= 2.0));
assert_eq!(states.last().unwrap().0, 2.0);
}
/// Après le dernier échantillon, la vue continue de rattraper un pointeur immobile hors de la
/// zone morte, jusqu'à son bord, au lieu de se figer.
#[test]
fn the_follow_view_keeps_settling_after_the_last_sample() {
// Le pointeur saute à 0,8 au dernier échantillon (2 s) ; bord de la zone à ×2 : 0,675.
let track = CursorTrack::new(
(0..=60)
.map(|i| (i as f32 / 30.0, if i == 60 { 0.8 } else { 0.5 }, 0.5))
.collect(),
vec![],
vec![],
);
let at = |t: f32| track.follow_in_view(0.0, t, 9.0, 2.0).unwrap().0;
assert!(
at(2.0) < at(2.5) && at(2.5) < at(4.0),
"{} {} {}",
at(2.0),
at(2.5),
at(4.0)
);
assert!((at(8.0) - 0.675).abs() < 1e-3, "{}", at(8.0));
}
#[test]
fn the_auto_follow_holds_still_inside_its_dead_zone() {
// ×2 : vue de 0,5, zone morte de ±0,125 autour de son centre.
let track = |f: fn(f32) -> f32| {
CursorTrack::new(
(0..=300)
.map(|i| {
let t = i as f32 / 30.0;
(t, f(t), 0.5)
})
.collect(),
vec![],
vec![],
)
};
let jitter = track(|t| 0.5 + 0.08 * (t * 7.0).sin());
for i in 0..=90 {
let (x, y) = jitter
.follow_in_view(0.0, i as f32 / 10.0, 9.0, 2.0)
.unwrap();
assert!(
(x - 0.5).abs() < 1e-6 && (y - 0.5).abs() < 1e-6,
"t {} : {x}",
i as f32 / 10.0
);
}
// Sans zone morte, le suivi lissé, lui, tremble.
let swing = (0..=90)
.map(|i| jitter.follow_at(i as f32 / 10.0).unwrap().0)
.fold(0.0f32, |m, x| m.max((x - 0.5).abs()));
assert!(swing > 0.02, "{swing}");
// Un saut à 0,8 à 2 s : la vue rattrape jusqu'à laisser le pointeur au bord de la zone.
let jump = track(|t| if t < 2.0 { 0.5 } else { 0.8 });
let settled = jump.follow_in_view(0.0, 9.0, 9.0, 2.0).unwrap().0;
assert!((settled - (0.8 - 0.125)).abs() < 1e-3, "{settled}");
let early = jump.follow_in_view(0.0, 2.1, 9.0, 2.0).unwrap().0;
assert!(
early > 0.5 && early < settled,
"rattrapage progressif : {early}"
);
// Une pure fonction de (t0, t, t_end) : l'ordre des appels ne change rien.
assert_eq!(jump.follow_in_view(0.0, 2.1, 9.0, 2.0).unwrap().0, early);
}
/// L'état du curseur est une fonction en escalier : il tient jusqu'à la transition
/// suivante, il n'est pas interpolé, et avant la première il n'y en a pas.
#[test]
fn cursor_type_holds_until_the_next_transition() {
let track = CursorTrack::new(
vec![(0.0, 0.0, 0.0), (2.0, 1.0, 1.0)],
vec![],
vec![
(0.5, "arrow".into()),
(1.0, "text".into()),
(1.5, "pointer".into()),
],
);
assert_eq!(track.type_at(0.0), None, "avant la première transition");
assert_eq!(
track.type_at(0.5),
Some("arrow"),
"à l'instant même de la transition"
);
assert_eq!(
track.type_at(0.9),
Some("arrow"),
"tient jusqu'à la suivante"
);
assert_eq!(track.type_at(1.2), Some("text"));
assert_eq!(
track.type_at(99.0),
Some("pointer"),
"la dernière tient jusqu'à la fin"
);
}
/// Le lissage déplace la trajectoire, pas la chronologie : les états doivent survivre
/// intacts à `smoothed()`, comme les clics.
#[test]
fn smoothing_preserves_cursor_types() {
let track = CursorTrack::new(
vec![(0.0, 0.0, 0.0), (0.5, 0.4, 0.4), (1.0, 1.0, 1.0)],
vec![0.25],
vec![(0.0, "arrow".into()), (0.6, "text".into())],
);
let smoothed = track.smoothed(0.4);
assert_eq!(smoothed.type_at(0.1), Some("arrow"));
assert_eq!(smoothed.type_at(0.7), Some("text"));
}
#[test]
fn load_preserves_hidden_intervals_and_ignores_hidden_clicks() {
let unique = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let path = std::env::temp_dir().join(format!(
"openscreen-cursor-visibility-{}-{}.json",
std::process::id(),
unique
));
std::fs::write(
&path,
r#"{"samples":[
{"timeMs":0,"cx":0.1,"cy":0.1,"visible":true},
{"timeMs":100,"cx":0.2,"cy":0.2,"visible":false,"interactionType":"click"},
{"timeMs":600,"cx":0.9,"cy":0.9,"visible":true,"interactionType":"click"}
]}"#,
)
.expect("write temp sidecar");
let path_str = path.to_str().expect("utf-8 temp path");
let track = CursorTrack::load(path_str, 0.0, 1.0).expect("load sidecar");
let clipped = CursorTrack::load(path_str, 200.0, 0.5).expect("load clipped sidecar");
let _ = std::fs::remove_file(&path);
assert!(track.visible_at(0.0));
assert!(!track.visible_at(0.1));
assert!(!track.visible_at(0.59));
assert!(track.visible_at(0.6));
assert_eq!(
track.clicks,
vec![0.6],
"le clic masqué ne doit pas animer le curseur"
);
assert!(
!clipped.visible_at(0.0),
"la fenêtre commence dans la phase masquée"
);
assert!(
!clipped.visible_at(0.39),
"l'état masqué tient jusqu'à la transition"
);
assert!(
clipped.visible_at(0.4),
"la transition visible garde son temps relatif"
);
let smoothed = track.smoothed(0.5);
assert!(
!smoothed.visible_at(0.3),
"le lissage garde la phase masquée"
);
assert!(smoothed.visible_at(0.6));
let reappeared = smoothed.at(0.6).expect("position at reappearance");
assert!(
(reappeared.0 - 0.9).abs() < 0.02 && (reappeared.1 - 0.9).abs() < 0.02,
"le ressort redémarre au point visible, sans traîne: {reappeared:?}"
);
}
#[test]
fn legacy_tracks_without_visibility_stay_visible() {
let track = CursorTrack::new(vec![(0.0, 0.1, 0.1), (1.0, 0.9, 0.9)], vec![], vec![]);
assert!(track.visible_at(0.0));
assert!(track.visible_at(0.5));
assert!(track.visible_at(10.0));
}
/// JSON null et une clé `cursorType` absente resetent vers la flèche,
/// au lieu de garder le dernier `pointer`/`text`.
#[test]
fn null_cursor_type_resets_to_arrow() {
let unique = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let path = std::env::temp_dir().join(format!(
"openscreen-cursor-null-reset-{}-{}.json",
std::process::id(),
unique
));
std::fs::write(
&path,
r#"{"samples":[
{"timeMs":0,"cx":0.1,"cy":0.1,"cursorType":"pointer"},
{"timeMs":100,"cx":0.2,"cy":0.2,"cursorType":null},
{"timeMs":200,"cx":0.3,"cy":0.3,"cursorType":"pointer"},
{"timeMs":300,"cx":0.4,"cy":0.4}
]}"#,
)
.expect("write temp sidecar");
let path_str = path.to_str().expect("utf-8 temp path");
let track = CursorTrack::load(path_str, 0.0, 1.0).expect("load sidecar");
let _ = std::fs::remove_file(&path);
assert_eq!(track.type_at(0.00), Some("pointer"));
assert_eq!(
track.type_at(0.10),
Some("arrow"),
"JSON null must reset to arrow"
);
assert_eq!(
track.type_at(0.20),
Some("pointer"),
"pointer after null must hold until the omitted-key sample"
);
assert_eq!(
track.type_at(0.30),
Some("arrow"),
"omitted cursorType after pointer must reset to arrow independently"
);
}
/// Deux clics à 60 ms, sur deux points distincts : la pointe se pose sur chacun à son instant, et
/// passe de l'un à l'autre sans sauter d'une image à l'autre.
#[test]
fn close_clicks_on_distinct_points_glide_between_them() {
let samples = vec![(0.0, 0.2, 0.2), (1.0, 0.2, 0.2), (1.06, 0.6, 0.5), (2.0, 0.6, 0.5)];
let track = CursorTrack::new(samples, vec![1.0, 1.06], vec![]).smoothed(0.67);
let (a, b): ((f32, f32), (f32, f32)) = ((0.2, 0.2), (0.6, 0.5));
assert_eq!(track.pinned_at(1.0), Some(a));
assert_eq!(track.pinned_at(1.06), Some(b));
let gap = (b.0 - a.0).hypot(b.1 - a.1);
for k in 1000..1060 {
let p = track.pinned_at(k as f32 * 0.001).unwrap();
let q = track.pinned_at((k + 1) as f32 * 0.001).unwrap();
let step = (q.0 - p.0).hypot(q.1 - p.1);
assert!(step < 0.06 * gap, "{k} ms : saut de {step}");
}
}
/// `pinned_at` pose le curseur sur le point BRUT du clic pendant le contact, même quand la
/// piste lissée traîne loin derrière, reste continue, et rend `at()` loin des clics.
#[test]
fn the_pinned_position_holds_the_raw_click_point() {
// Un geste rapide de 0,1 à 0,7 qui s'arrête pile sur le clic, puis repart vers le bas.
let samples: Vec<(f32, f32, f32)> = (0..=60)
.map(|k| {
let t = k as f32 / 30.0;
let x = 0.1 + 0.6 * (t / 1.0).min(1.0);
let y = 0.5 + 0.3 * ((t - 1.0) / 0.3).clamp(0.0, 1.0);
(t, x, y)
})
.collect();
let raw = CursorTrack::new(samples, vec![1.0], vec![]);
let clicked = raw.at(1.0).unwrap();
for track in [raw.smoothed(0.0), raw.smoothed(0.5), raw.smoothed(1.0)] {
let lag = track.at(1.0).unwrap();
for ms in 0..=100 {
let t = 1.0 + ms as f32 / 1000.0;
assert_eq!(track.pinned_at(t), Some(clicked), "{ms} ms après le clic");
}
// Loin des clics : la piste telle quelle.
for t in [0.5, 0.74, 1.36, 1.8] {
assert_eq!(track.pinned_at(t), track.at(t), "t = {t}");
}
// Continue : pas de saut d'une milliseconde à l'autre.
for k in 0..2000 {
let (a, b) = (
track.pinned_at(k as f32 * 0.001).unwrap(),
track.pinned_at((k + 1) as f32 * 0.001).unwrap(),
);
assert!(
(a.0 - b.0).abs() < 4e-3 && (a.1 - b.1).abs() < 4e-3,
"saut en {k} ms : {a:?} -> {b:?}"
);
}
println!("au clic, piste en {lag:?}, point cliqué {clicked:?}");
}
// Le lissage traîne bel et bien : sans la convergence, le contact tomberait à côté.
assert!(raw.smoothed(0.5).at(1.0).unwrap().0 < 0.69);
}
/// Enveloppe du click bounce : neutre hors fenêtre, continue aux jonctions, creux à 0.76 et
/// pic à 1.16 aux bons instants, et un nouveau clic redémarre la courbe.
#[test]
fn click_bounce_envelope() {
let near = |a: f32, b: f32, tol: f32| (a - b).abs() < tol;
let track = CursorTrack::new(vec![], vec![1.0], vec![]);
let b = |t: f32| track.bounce(t);
// Exactement neutre avant le premier clic et après la fenêtre de 260 ms.
assert_eq!(b(0.0), 1.0);
assert_eq!(b(0.999), 1.0);
assert_eq!(b(1.2601), 1.0);
assert_eq!(b(5.0), 1.0);
// Continuité aux jonctions (fraction 0, 0.38 et 1) : ±0.1 ms autour reste à ~1.
const DT: f32 = 1e-4;
assert_eq!(b(1.0), 1.0, "fraction 0");
assert!(near(b(1.0 + DT), 1.0, 2e-3));
let press_end = 1.0 + 0.38 * 0.26;
assert!(
near(b(press_end - DT), 1.0, 2e-3),
"fraction 0.38⁻ : {}",
b(press_end - DT)
);
assert!(
near(b(press_end + DT), 1.0, 2e-3),
"fraction 0.38⁺ : {}",
b(press_end + DT)
);
assert!(
near(b(1.26 - DT), 1.0, 2e-3),
"fraction 1⁻ : {}",
b(1.26 - DT)
);
// Creux de la pression (fraction 0.19 → +49.4 ms), pic du rebond (0.69 → +179.4 ms).
assert!(near(b(1.0494), 0.76, 1e-4), "creux : {}", b(1.0494));
assert!(near(b(1.1794), 1.16, 1e-4), "pic : {}", b(1.1794));
assert!(b(1.03) > 0.76 && b(1.07) > 0.76, "le creux est un minimum");
assert!(b(1.15) < 1.16 && b(1.21) < 1.16, "le pic est un maximum");
// Seul le clic le plus récent compte : le second redémarre la courbe. À 1.1 s le premier
// serait encore dans son rebond (≈1.0037), le second l'écrase à 1.0 pile.
let double = CursorTrack::new(vec![], vec![1.0, 1.1], vec![]);
assert_eq!(double.bounce(1.1), 1.0, "redémarrage à la fraction 0");
assert!(
near(double.bounce(1.1494), 0.76, 1e-4),
"nouveau creux : {}",
double.bounce(1.1494)
);
assert!(
near(double.bounce(1.2794), 1.16, 1e-4),
"nouveau pic : {}",
double.bounce(1.2794)
);
assert_eq!(
double.bounce(1.3601),
1.0,
"neutre après la fenêtre du second clic"
);
}
#[test]
fn auto_hide_disabled_always_full_opacity() {
let track = CursorTrack::new(vec![(0.0, 0.5, 0.5), (10.0, 0.5, 0.5)], vec![], vec![]);
assert_eq!(track.opacity_at(0.0, false), 1.0);
assert_eq!(track.opacity_at(5.0, false), 1.0);
assert_eq!(track.opacity_at(10.0, false), 1.0);
}
#[test]
fn auto_hide_fades_out_after_idle_timeout() {
// Le curseur est stationnaire à (0.5, 0.5) de 0 à 5s.
let track = CursorTrack::new(
vec![
(0.0, 0.5, 0.5),
(1.0, 0.5, 0.5),
(2.0, 0.5, 0.5),
(3.0, 0.5, 0.5),
(4.0, 0.5, 0.5),
],
vec![],
vec![],
);
// Pendant 1.5s, opacité 1.0
assert_eq!(track.opacity_at(0.0, true), 1.0);
assert_eq!(track.opacity_at(1.0, true), 1.0);
assert_eq!(track.opacity_at(1.5, true), 1.0);
// Entre 1.5s et 1.8s, estompage linéaire
let op_mid = track.opacity_at(1.65, true);
assert!(
(op_mid - 0.5).abs() < 0.05,
"mi-parcours d'estompage: {op_mid}"
);
// À 1.8s et au-delà, opacité 0.0
assert_eq!(track.opacity_at(1.8, true), 0.0);
assert_eq!(track.opacity_at(3.0, true), 0.0);
}
#[test]
fn auto_hide_wakes_on_movement_or_click() {
// Reste immobile jusqu'à 2s, bouge à 2.5s, s'arrête, clic à 4.0s
let track = CursorTrack::new(
vec![
(0.0, 0.1, 0.1),
(1.0, 0.1, 0.1),
(2.0, 0.1, 0.1),
(2.5, 0.8, 0.8), // mouvement net
(2.6, 0.8, 0.8),
(4.0, 0.8, 0.8),
(5.0, 0.8, 0.8),
],
vec![4.0], // clic à 4.0s
vec![],
);
// À 1.9s, inactif depuis 0s -> 0.0
assert_eq!(track.opacity_at(1.9, true), 0.0);
// À 2.5s, vient de bouger -> réveil à 1.0
assert_eq!(track.opacity_at(2.5, true), 1.0);
// À 3.5s, 1s après le mouvement -> toujours 1.0
assert_eq!(track.opacity_at(3.5, true), 1.0);
// Sans le clic à 4.0, à 4.5s (2s après 2.5) il serait éteint.
// Mais le clic à 4.0s le réveille -> 1.0
assert_eq!(track.opacity_at(4.2, true), 1.0);
// Et s'éteint 1.8s après le clic (4.0 + 1.8 = 5.8s)
assert_eq!(track.opacity_at(5.9, true), 0.0);
}
}