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): let the bounce level drive the 3D cursor's whole click gesture

EtienneLescot36c8d397404c
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs
index b34a37a08..d6a90d31d 100644
--- a/crates/compositor/src/cursor.rs
+++ b/crates/compositor/src/cursor.rs
@@ -18,7 +18,7 @@ const AUTO_FOLLOW_REFERENCE_MS: f32 = 1000.0 / 40.0;
const FOLLOW_DEAD_ZONE: f32 = 0.5;
// Convergence du curseur dessiné sur le point cliqué (`pinned_at`). La tenue couvre le contact du
-// curseur modélisé (27 à 74 ms après le clic), plus une image à 24 i/s.
+// curseur modélisé : de 27 à 74 ms après le clic à « Light », de 12 à 100 ms à « Strong ».
const PIN_APPROACH_S: f32 = 0.25;
const PIN_HOLD_S: f32 = 0.1;
const PIN_RELEASE_S: f32 = 0.25;
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index bdf91a31c..fa0d1837d 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -3746,9 +3746,14 @@ pub const MODEL_LIGHT: [f32; 3] = [-0.4194, -0.5792, 0.6990];
/// Garde au sol au repos, en unités du modèle.
const MODEL_HOVER: f32 = 0.35;
-/// Gain sur `tap` pour la descente : à 1,25 le modèle reste posé de 27 à 74 ms après le clic,
-/// assez pour qu'au moins une image le montre au contact jusqu'à 21 i/s.
+/// Gain sur `tap` pour la descente, fois le niveau de `clickBounce` : à « Light » (1) le modèle
+/// reste posé de 27 à 74 ms après le clic, assez pour qu'au moins une image le montre au contact
+/// jusqu'à 21 i/s ; à « Strong » (2), il touche dès 12 ms et appuie jusqu'à 100 ms (la tenue de
+/// `CursorTrack::pinned_at`) ; à « None », il ne descend pas.
const MODEL_CONTACT_GAIN: f32 = 1.25;
+/// Rebond au-dessus du survol, sur la remontée de `tap` (+0,164 à 165 ms), fois le niveau : il
+/// remonte de 41 % de sa hauteur de survol à « Light », de 82 % à « Strong ».
+const MODEL_REBOUND_GAIN: f32 = 2.5;
/// Tangage au repos (queue relevée, pointe vers le bas) et supplément au creux de la pression.
const MODEL_PITCH_IDLE_DEG: f32 = 18.0;
const MODEL_PITCH_PRESS_DEG: f32 = 10.0;
@@ -3853,20 +3858,23 @@ pub struct CursorPose {
/// La pose à `t`. `click_bounce` est le réglage brut (0 à 2 : None, Light, Strong ; 1 par défaut),
/// `pointing` la part « pointeur » du sprite (`pointing_factor`).
///
-/// - Hauteur : `MODEL_HOVER` au repos ; chaque clic le fait descendre TOUCHER le plan au creux de
-/// `regions::tap`, la courbe de l'impact du clic, dont le creux (49,5 ms) est celui de la
-/// pression de `CursorTrack::bounce` : le modèle, le plan et le rebond d'échelle lisent le même
-/// contact à la même image. Dernier clic avant `t`, comme `bounce`. Tous les états.
-/// - Tangage : 18° au repos, jusqu'à +10° au creux de la pression, fois `clickBounce`.
+/// - Hauteur : `MODEL_HOVER` au repos ; chaque clic le fait descendre TOUCHER le plan autour du
+/// creux de `regions::tap`, la courbe de l'impact du clic, dont le creux (49,5 ms) est celui de
+/// la pression de `CursorTrack::bounce` : le modèle, le plan et le rebond d'échelle lisent le
+/// même contact à la même image. Puis il rebondit au-dessus du survol et s'y repose. Le niveau
+/// règle tout le geste, comme le rebond d'échelle en 2D : plus fort, il touche plus tôt, appuie
+/// plus longtemps et rebondit plus haut (`MODEL_CONTACT_GAIN`, `MODEL_REBOUND_GAIN`) ; à 0, il
+/// ne bouge pas. Dernier clic avant `t`, comme `bounce`. Tous les états.
+/// - Tangage : 18° au repos, +10° pendant l'appui, fois `clickBounce`.
/// - Lacet : vers la vitesse horizontale lissée (`follow_at`, différence centrée), et vers la
/// cible d'un clic dans les 300 ms qui le précèdent ; borné à ±25° en douceur (`tanh`), nul au
/// repos. Les contributions des clics montent avant eux et retombent sur la fenêtre de l'impact,
/// donc la pose reste continue en `t`.
/// - Tangage et lacet sont multipliés par `pointing` : entiers pour la flèche, nuls pour un
/// curseur centré.
-/// - Écrasement : sur la même courbe `tap`, l'épaisseur descend à 1 − `MODEL_SQUASH` au creux,
-/// puis le rebond l'épaissit un instant. Fois `clickBounce`, comme le tangage ; tous les états.
-/// L'empreinte ne change pas : pas de rebond d'échelle en 3D.
+/// - Écrasement : pendant l'appui, l'épaisseur descend à 1 − `MODEL_SQUASH`, puis le rebond
+/// l'épaissit un instant. Fois `clickBounce`, comme le tangage ; tous les états.
+/// L'empreinte ne change pas : pas de rebond d'échelle en 3D, le mouvement le remplace.
pub fn cursor_pose(
track: &crate::cursor::CursorTrack,
t: f32,
@@ -3875,11 +3883,14 @@ pub fn cursor_pose(
) -> CursorPose {
use crate::regions::{tap, CLICK_IMPACT_WINDOW_S};
let k = track.last_click_at(t).map(|tc| tap((t - tc) / CLICK_IMPACT_WINDOW_S)).unwrap_or(0.0);
- let clearance = MODEL_HOVER * (1.0 + MODEL_CONTACT_GAIN * k).max(0.0);
let strength = (click_bounce / MODEL_CLICK_BOUNCE_REF).clamp(0.0, 2.0);
- let press = (-k).max(0.0) * strength;
- let pitch = pointing * (MODEL_PITCH_IDLE_DEG + MODEL_PITCH_PRESS_DEG * press).to_radians();
- let squash = (1.0 + MODEL_SQUASH * k * strength).max(MODEL_SQUASH_MIN);
+ // L'appui, de 0 au survol à 1 posé, et le rebond au-dessus du survol.
+ let press = (-k * MODEL_CONTACT_GAIN * strength).clamp(0.0, 1.0);
+ let rebound = k.max(0.0) * strength;
+ let clearance = MODEL_HOVER * (1.0 - press + MODEL_REBOUND_GAIN * rebound);
+ let pitch =
+ pointing * (MODEL_PITCH_IDLE_DEG + MODEL_PITCH_PRESS_DEG * strength * press).to_radians();
+ let squash = (1.0 + MODEL_SQUASH * (rebound - strength * press)).max(MODEL_SQUASH_MIN);
let smooth = |x: f32| {
let u = x.clamp(0.0, 1.0);
@@ -7770,10 +7781,18 @@ mod tests {
let press_ms = press.expect("un creux") as f32;
assert_eq!(cursor_pose(&track, 0.5 + press_ms / 1000.0, MODEL_CLICK_BOUNCE_REF, 1.0).clearance, 0.0);
assert_eq!(cursor_pose(&track, 0.5 + crate::regions::CLICK_IMPACT_WINDOW_S, MODEL_CLICK_BOUNCE_REF, 1.0), rest);
- // clickBounce règle la pression, pas le contact.
- let soft = cursor_pose(&track, 0.5 + CONTACT_S, 0.0, 1.0);
- assert_eq!(soft.clearance, 0.0);
- assert!((soft.pitch - rest.pitch).abs() < 1e-6);
+ // Le niveau règle tout le geste. « None » : le modèle ne bouge pas au clic.
+ for ms in 0..260 {
+ assert_eq!(cursor_pose(&track, 0.5 + ms as f32 / 1000.0, 0.0, 1.0), rest, "{ms} ms");
+ }
+ // « Strong » : il touche plus tôt, appuie plus longtemps et plus penché, rebondit plus haut.
+ let at = |ms: f32, level: f32| cursor_pose(&track, 0.5 + ms / 1000.0, level, 1.0);
+ let posed = |level: f32| (0..260).filter(|&ms| at(ms as f32, level).clearance == 0.0).count();
+ assert!(at(15.0, 2.0).clearance == 0.0 && at(15.0, 1.0).clearance > 0.0, "plus tôt");
+ assert!(posed(2.0) > posed(1.0) + 30, "plus longtemps : {} ms / {} ms", posed(2.0), posed(1.0));
+ assert!(at(CONTACT_S * 1000.0, 2.0).pitch > down.pitch + 5f32.to_radians(), "plus penché");
+ let peak = |level: f32| (100..260).map(|ms| at(ms as f32, level).clearance).fold(0.0, f32::max);
+ assert!(peak(1.0) > MODEL_HOVER * 1.3 && peak(2.0) > peak(1.0) + 0.3 * MODEL_HOVER, "plus haut");
}
/// « Posé » veut dire posé, pour chaque état : au repos le point le plus bas du modèle est à
diff --git a/crates/compositor/tests/cursor_tap_render.rs b/crates/compositor/tests/cursor_tap_render.rs
index 8500b163c..af0bd362a 100644
--- a/crates/compositor/tests/cursor_tap_render.rs
+++ b/crates/compositor/tests/cursor_tap_render.rs
@@ -370,6 +370,69 @@ fn the_impact_ring_is_centred_on_the_click() {
assert!(late == late_quiet, "l'anneau survit à sa fenêtre");
}
+/// Planche des niveaux du clic (opt-in, `OPENSCREEN_CURSOR_TAP_OUT`) : None, Light et Strong en
+/// lignes, des instants autour du clic de la flèche en colonnes, agrandis ×2 autour de la pointe.
+/// Et la même chose en mouvement, les trois niveaux côte à côte, à 30 i/s puis ralentie ×4.
+#[test]
+fn cursor_press_levels() {
+ let Ok(dir) = std::env::var("OPENSCREEN_CURSOR_TAP_OUT") else {
+ eprintln!("OPENSCREEN_CURSOR_TAP_OUT absent — saute");
+ return;
+ };
+ let Some(gpu) = gpu() else { return };
+ let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");
+ let screen = MockFrame::new(&gpu);
+ let track = gesture("levels");
+ let frames = format!("{dir}/levels");
+ std::fs::create_dir_all(&frames).expect("dossier des frames");
+ let ([_, _], tc) = TARGETS[0];
+ let levels = [0.0, 1.0, 2.0];
+ let img = |rgba: Vec<u8>| image::RgbaImage::from_raw(OUT.0, OUT.1, rgba).expect("readback");
+ let (_, tip) = render(&comp, &screen, &scene_json("null", false, 1.0), &track, tc + CONTACT_S);
+ let tip = tip.expect("curseur");
+ const CELL: u32 = 180;
+ let cell = |rgba: Vec<u8>| {
+ let (x, y) = ((tip[0] - CELL as f32 * 0.35) as u32, (tip[1] - CELL as f32 * 0.3) as u32);
+ image::imageops::crop_imm(&img(rgba), x, y, CELL, CELL).to_image()
+ };
+ let offsets = [-0.1, 0.0, 0.017, 0.033, 0.05, 0.083, 0.117, 0.15, 0.2, 0.27];
+ let mut sheet = image::RgbaImage::new(offsets.len() as u32 * 2 * CELL, levels.len() as u32 * 2 * CELL);
+ for (row, level) in levels.iter().enumerate() {
+ for (col, dt) in offsets.iter().enumerate() {
+ let (rgba, _) = render(&comp, &screen, &scene_json("null", false, *level), &track, tc + dt);
+ let big = image::imageops::resize(&cell(rgba), 2 * CELL, 2 * CELL, image::imageops::FilterType::Nearest);
+ image::imageops::overlay(&mut sheet, &big, (col as u32 * 2 * CELL) as i64, (row as u32 * 2 * CELL) as i64);
+ }
+ }
+ sheet.save(format!("{dir}/press-levels.png")).expect("planche");
+ println!("planche des niveaux : lignes {levels:?}, colonnes {offsets:?} s après le clic");
+ for (speed, name) in [(1.0, "press-levels.mp4"), (0.25, "press-levels-slow.mp4")] {
+ let n = (0.6 / speed * 30.0) as u32;
+ for k in 0..n {
+ let t = tc - 0.2 + k as f32 / 30.0 * speed;
+ let mut row = image::RgbaImage::new(levels.len() as u32 * 2 * CELL, 2 * CELL);
+ for (i, level) in levels.iter().enumerate() {
+ let (rgba, _) = render(&comp, &screen, &scene_json("null", false, *level), &track, t);
+ let big = image::imageops::resize(&cell(rgba), 2 * CELL, 2 * CELL, image::imageops::FilterType::Triangle);
+ image::imageops::overlay(&mut row, &big, (i as u32 * 2 * CELL) as i64, 0);
+ }
+ row.save(format!("{frames}/{k:03}.png")).expect("frame");
+ }
+ let ffmpeg = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+ .join("../thirdparty/ffmpeg-n8.1.2-win64-lgpl-shared/bin/ffmpeg.exe");
+ let status = std::process::Command::new(ffmpeg)
+ .args(["-y", "-loglevel", "error", "-framerate", "30", "-i"])
+ .arg(format!("{frames}/%03d.png"))
+ .args(["-c:v", "h264_mf", "-b:v", "8M", "-pix_fmt", "nv12"])
+ .arg(format!("{dir}/{name}"))
+ .status();
+ println!("ffmpeg : {status:?} -> {dir}/{name}");
+ for k in 0..n {
+ let _ = std::fs::remove_file(format!("{frames}/{k:03}.png"));
+ }
+ }
+}
+
/// Vidéo et planche à regarder (opt-in, `OPENSCREEN_CURSOR_TAP_OUT`).
#[test]
fn cursor_tap_video() {
diff --git a/docs/3d-effects-v2.md b/docs/3d-effects-v2.md
index 52e266667..2693c7152 100644
--- a/docs/3d-effects-v2.md
+++ b/docs/3d-effects-v2.md
@@ -327,10 +327,15 @@ Deux décisions :
- **Hauteur** : 0,35 unité de garde au repos. Chaque clic le pose **au contact** avec la courbe
`tap()`, celle de l'impact du clic, dont le creux (49,5 ms) est celui de la pression de
- `bounce()`. Gain 1,25 : posé de 27 à 74 ms, donc au moins une image au contact jusqu'à
- 21 i/s. Tous les états.
-- **Tangage** : queue relevée, pointe vers le bas, 18° au repos, jusqu'à +10° au creux de la
- pression, fois `clickBounce` (« Light » = 1, le défaut ; « Strong » = 2).
+ `bounce()`, puis il **rebondit** au-dessus de sa garde et s'y repose. Tous les états.
+- **Le niveau `clickBounce` règle tout le geste**, comme le rebond d'échelle en 2D : l'appui est
+ `tap()` × 1,25 × niveau, borné à 1, le rebond la remontée de `tap()` × 2,5 × niveau.
+ « Light » (1, le défaut) : posé de 27 à 74 ms, donc au moins une image au contact jusqu'à
+ 21 i/s, rebond à +41 % de la garde. « Strong » (2) : posé de 12 à 100 ms, rebond à +82 %.
+ « None » : le modèle ne bouge pas au clic. Auparavant, contact et rebond ne dépendaient pas du
+ niveau : de face, les trois se ressemblaient (retour produit du 27/09/2026).
+- **Tangage** : queue relevée, pointe vers le bas, 18° au repos, +10° pendant l'appui, fois le
+ niveau.
- **Lacet** : vers la vitesse horizontale lissée (`follow_at`, différence centrée sur ±100 ms),
et vers la cible d'un clic dans les 300 ms qui le précèdent. Borné en douceur à ±25°
(`tanh`), nul au repos, continu en `t`.
@@ -347,8 +352,8 @@ Deux décisions :
repos, au plan au contact, jamais dessous. Mesuré sur huit états, à plat et iso : 0 pour les
états centrés (face du dessous au sol), +1,6 à +1,8 % d'unité pour les pointeurs (le chanfrein
arrondit le coin qui touche), sous le seuil testé de 2 %.
-- **Pas de rebond d'échelle** en 3D : le contact le remplace.
-- **Écrasement** : sur la même courbe `tap()`, l'épaisseur descend à 70 % au creux, puis le
+- **Pas de rebond d'échelle** en 3D : le geste le remplace, en vrai relief.
+- **Écrasement** : pendant l'appui, l'épaisseur descend à 70 %, puis le
rebond l'épaissit un instant (104,8 % à 165 ms). Fois `clickBounce`, jamais sous 55 %
(deux chanfreins et un peu de flanc). Le dessus descend, le point le plus bas reste posé, le
hotspot reste sur son pixel. L'empreinte, elle, ne change pas : un étalement de 5 % défaisait