Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

fix(cursor): land the flat cursor on each click, and smooth less by default

EtienneLescot836d06967e09
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs
index d9c104a82..052ecf726 100644
--- a/crates/compositor/src/cursor.rs
+++ b/crates/compositor/src/cursor.rs
@@ -368,7 +368,9 @@ impl CursorTrack {
/// 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. Continue et de pente continue en `t` ; hors de ces fenêtres, `at(t)` à l'identique.
+ /// 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. Continue et de pente 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
@@ -378,7 +380,11 @@ impl CursorTrack {
for i in lo..hi.max(lo) {
let d = t - self.clicks[i];
let w = if d < 0.0 {
- smoothstep01(1.0 + d / PIN_APPROACH_S)
+ let approach = match i.checked_sub(1) {
+ Some(p) => (self.clicks[i] - self.clicks[p] - PIN_HOLD_S).clamp(1e-3, PIN_APPROACH_S),
+ None => PIN_APPROACH_S,
+ };
+ smoothstep01(1.0 + d / approach)
} else {
1.0 - smoothstep01((d - PIN_HOLD_S) / PIN_RELEASE_S)
};
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index f7affa9dc..f189f6f37 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -3834,11 +3834,11 @@ impl<'a> CursorPlacer<'a> {
}
}
- /// La pointe à `t`. Le curseur modélisé touche le plan à chaque clic : il se pose sur le point
- /// cliqué brut (`pinned_at`), pas sur la piste lissée qui traîne derrière la souris. Le sprite
- /// plat garde la piste telle quelle, son rendu est celui d'avant.
+ /// La pointe à `t`, posée sur le point cliqué brut à chaque clic (`pinned_at`), pas sur la piste
+ /// lissée qui traîne derrière la souris. Sprite plat comme modèle 3D : le rebond, l'anneau
+ /// d'impact et `ctx.clicks` se centrent sur ce point brut, la pointe doit s'y trouver.
fn at(&self, t: f32) -> Option<(f32, f32)> {
- if self.model3d { self.track.pinned_at(t) } else { self.track.at(t) }
+ self.track.pinned_at(t)
}
/// `None` hors de la coupe courante (zoom serré, hors écran).
@@ -9279,6 +9279,30 @@ mod tests {
assert_eq!(fx(2.5).cursor, Some(drawn.placement.upright_center()), "là où le curseur se dessine");
}
+ /// Le sprite plat aussi se pose sur le clic brut : à fort lissage, le ressort traîne loin derrière
+ /// une souris qui clique dès l'arrivée, mais la pointe dessinée, `ctx.cursor` et `ctx.clicks`
+ /// tombent sur le même pixel pendant le contact.
+ #[test]
+ fn the_flat_cursor_lands_on_the_click_under_smoothing() {
+ const TC: f32 = 1.5;
+ let scene = model_scene();
+ let cfg = crate::config::all().pop().expect("cfg");
+ let fg = full_frame_geometry();
+ let raw = approach_track([0.08, 0.05], [0.7, 0.6], [0.2, 0.9], 2.0, 0.0, TC);
+ for smoothing in [0.0, 0.3, 0.67, 1.0] {
+ let track = raw.smoothed(smoothing);
+ for ms in [0, 40, 100] {
+ let input = cursor_input(&scene, &cfg, &track, TC + ms as f32 / 1000.0);
+ let fx = effect_pointer(&fg, &input);
+ let (cursor, click) = (fx.cursor.expect("pointe"), fx.clicks[0].0);
+ let drawn = plan_cursor(&fg, &input).expect("visible").placement.upright_center();
+ let off = |a: [f32; 2], b: [f32; 2]| ((a[0] - b[0]) * 1920.0).hypot((a[1] - b[1]) * 1080.0);
+ assert!(off(cursor, click) < 0.5, "lissage {smoothing}, {ms} ms : {} px", off(cursor, click));
+ assert!(off(drawn, click) < 0.5, "lissage {smoothing}, {ms} ms : {} px", off(drawn, click));
+ }
+ }
+ }
+
/// Masqué par l'utilisateur, le curseur n'est plus dessiné, mais les effets gardent la pointe
/// et les clics : un halo suit toujours la souris, une onde part toujours du clic. Quand c'est
/// l'enregistrement qui cache la pointe, les effets la perdent, et gardent les clics d'avant.
diff --git a/src/lib/projectDefaults.ts b/src/lib/projectDefaults.ts
index 124c48034..cfb838241 100644
--- a/src/lib/projectDefaults.ts
+++ b/src/lib/projectDefaults.ts
@@ -264,7 +264,8 @@ export const DEFAULT_PROJECT_APPEARANCE: ProjectAppearanceDefaults = {
// 3.6 draws a 98 px arrow in a 1080p export, about five times the system one: the cursor
// effects are part of the product, and a smaller arrow plays them down. 6 reaches 164 px.
size: 3.6,
- smoothing: 0.67,
+ // About 95 ms of spring lag: 0.67 trailed the pointer by 190 ms, 150 px on a quick click.
+ smoothing: 0.3,
motionBlur: 0.35,
// A light tap: 2.5 squashed the arrow to 40% and threw it to 140% in 260 ms on every click.
clickBounce: 1,