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
fix(compositor): keep the cursor's size at the zoom focus under Left and Right
EtienneLescot7abf7449091d
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex f52933405..a79c5f527 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -3393,7 +3393,8 @@ pub struct CursorPlan {pub placement: CursorPlacement,/// Placement à `t - trail_frames/FPS`, pour la traînée. `placement` quand il n'y en a pas.pub prev_placement: CursorPlacement,- /// Côté du sprite en px de sortie (bounce et padding déjà appliqués).+ /// Côté du sprite en px de sortie (bounce et padding déjà appliqués). Sous un angle fixe, le+ /// côté sur le plan qui donne cette taille au point de focus.pub size_px: f32,/// Nombre d'échantillons de la traînée. 1 = curseur net, pas d'accumulation.pub taps: u32,@@ -3590,6 +3591,18 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorP};let size_px =CURSOR_BASE_SIZE_FRAC * g.screen_unit_px * lp.cursor_size_scale * bounce * g.padding_scale;+ // Sous un angle fixe, le plan tourne autour du centre de sa boîte ZOOMÉE, réduit de son+ // containment : au point de focus, un px du plan vaut `scale·P/(P − z)` px de sortie, ~0,84 au+ // zoom doré. Le curseur y rapetissait donc pendant que le zoom grossissait l'image. Il est+ // taillé pour faire `size_px` au focus ; ailleurs, seule la perspective le change. La caméra+ // réelle n'en a pas besoin : elle vise déjà le point regardé.+ let size_px = match (tilt.as_ref(), g.camera) {+ (Some(quad), None) => {+ let z = quad.depth_mb(s_px, g.focus_plane, false)[2];+ size_px * (quad.perspective - z) / (quad.perspective * quad.scale)+ }+ _ => size_px,+ };// Taille nulle = rien à dessiner, et surtout rien à projeter : sur un plan incliné les quatre// coins du sprite se confondent, et le warp inverse du mode 13 résout alors 0/0. Son rejet// ne tiendrait qu'à des comparaisons avec NaN, que Metal (fast-math) ne garantit pas.@@ -8256,4 +8269,63 @@ mod tests {assert_eq!(cpu.prev_placement.upright_center(), cpu.placement.upright_center());assert_eq!(plan(false).for_backend(true).taps, plan(false).taps, "le sprite plat garde sa traînée");}++ /// Sous un angle fixe, l'écran tourne autour du centre de sa boîte ZOOMÉE, réduit de son+ /// containment : le curseur y perdait ~18 % au point de focus même, pendant que le zoom+ /// grossissait l'image. Il y garde sa taille à plat, à la perspective de biais près ; ailleurs,+ /// seule la perspective le change : plus grand du côté proche, plus petit du côté lointain.+ #[test]+ fn a_fixed_angle_keeps_the_cursor_size_at_the_zoom_focus() {+ let cfg = crate::config::all().pop().expect("cfg");+ // Taille apparente du modèle posé en `at` (repère du curseur) : différences centrées de sa+ // projection autour de la pointe, en px de sortie par unité du modèle.+ let size = |rotation: &str, zoom: f32, at: (f32, f32)| -> f32 {+ let json = zoomed_golden_scene_json()+ .replace(r#""rotation":"none""#, &format!(r#""rotation":"{rotation}""#))+ .replace(r#""scale":2.0"#, &format!(r#""scale":{zoom}"#));+ let mut scene = Scene::from_json(&json).expect("scène");+ scene.cursor.theme = "default".into();+ scene.cursor.cursor_sprites = model_scene().cursor.cursor_sprites;+ let live = LiveParams { cursor_model3d: true, ..live_params_from_scene(&scene) };+ let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(+ crate::cursor::CursorTrack::new(vec![(0.0, at.0, at.1), (6.0, at.0, at.1)], vec![], vec![]),+ ));+ let g = plan_frame(&FrameGeometryInput { cursor: Some(track), live, ..golden_input(&scene, &cfg) });+ let input = CursorPlanInput {+ render_px: [1170.0, 658.0],+ u_max: 1.0,+ v_max: 1080.0 / 1088.0,+ cfg: &cfg,+ live,+ scene: Some(&scene),+ track,+ t: 1.5,+ };+ let plan = plan_cursor(&g, &input).expect("plan");+ let (_, shape) = sprite_model("arrow");+ let view = ModelView::new(plan.placement, plan.size_px, plan.model.expect("modèle"), shape).expect("vue");+ let e = 0.05 * view.unit;+ let span = |d: [f32; 3]| {+ let p = |k: f32| view.project([0, 1, 2].map(|i| view.tip[i] + k * d[i])).expect("projection");+ let (a, b) = (p(e), p(-e));+ (a[0] - b[0]).hypot(a[1] - b[1]) / (2.0 * e) * view.unit+ };+ (span([1.0, 0.0, 0.0]) * span([0.0, 1.0, 0.0])).sqrt()+ };+ // Le focus du zoom doré, (0,5 ; 0,3) du recadrage 0,61 : c'est là que regarde le zoom.+ let focus = (0.305, 0.183);+ for zoom in [1.25f32, 2.0, 3.5] {+ let flat = size("none", zoom, focus);+ for rotation in ["left", "right"] {+ let ratio = size(rotation, zoom, focus) / flat;+ println!("{rotation} ×{zoom} : {ratio:.3} de la taille à plat, au focus");+ assert!((0.93..1.02).contains(&ratio), "{rotation} ×{zoom} : {ratio}");+ }+ }+ // `left` amène le bord droit vers la caméra, `right` le bord gauche.+ let at_focus = size("left", 2.0, focus);+ let (near, far) = (size("left", 2.0, (0.43, 0.183)), size("left", 2.0, (0.18, 0.183)));+ println!("left ×2 : {:.3} côté proche, {:.3} côté lointain", near / at_focus, far / at_focus);+ assert!(near > 1.04 * at_focus && far < 0.96 * at_focus, "{near} {at_focus} {far}");+ }}diff --git a/crates/compositor/tests/cursor_model_render.rs b/crates/compositor/tests/cursor_model_render.rsindex aa54170de..4f2e4c842 100644--- a/crates/compositor/tests/cursor_model_render.rs+++ b/crates/compositor/tests/cursor_model_render.rs@@ -625,15 +625,18 @@ fn every_state_keeps_its_art_and_its_footprint() {assert!(failures.is_empty(), "{failures:#?}");}-/// Incliné et à plat, le modèle n'a pas la même silhouette : le plan l'emporte avec lui.+/// Incliné et à plat, le modèle n'a pas la même silhouette : le plan l'emporte avec lui. Au focus,+/// l'angle fixe lui garde sa taille (`plan_cursor`) : seule son orientation sépare les deux+/// silhouettes, et un demi-pixel de décalage en changerait autant de pixels. Les deux rendus+/// posent donc la pointe sur le même point, fraction de pixel comprise.#[test]fn the_tilt_turns_every_state_with_the_screen() {let Some(gpu) = gpu() else { return };let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");let screen = FakeFrame::new(&gpu, Tint::Blue);for key in TESTED {- let still = resting_as(&format!("tilt-{key}"), Some(key), false);- let mask = |rotation: &str| -> (Vec<bool>, Probe) {+ let mask = |rotation: &str, x: f32, y: f32| -> (Vec<bool>, Probe) {+ let still = track_as(&format!("tilt-{key}"), Some(key), &[(0.0, x, y, false), (9.0, x, y, false)]);let (rgba, p) = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &still);// Silhouette relative au hotspot, sur une fenêtre de ±1,1 unité.let r = (1.1 * p.unit) as i32;@@ -646,12 +649,20 @@ fn the_tilt_turns_every_state_with_the_screen() {}(m, p)};- let (flat, pf) = mask("null");- let (iso, pi) = mask(r#""iso""#);+ let (iso, pi) = mask(r#""iso""#, 0.45, 0.45);+ // À plat, l'écran couvre 1024 × 576 px depuis (128, 72) (`screenRect`) : la pointe s'y pose+ // sur celle du rendu incliné.+ let (flat, pf) = mask("null", (pi.tip[0] - 128.0) / 1024.0, (pi.tip[1] - 72.0) / 576.0);+ assert!(+ (pf.tip[0] - pi.tip[0]).abs() < 0.01 && (pf.tip[1] - pi.tip[1]).abs() < 0.01,+ "{key}: pointes {:?} et {:?}",+ pf.tip,+ pi.tip+ );let n = flat.len().min(iso.len());let differ = (0..n).filter(|&k| flat[k] != iso[k]).count();println!("{key} : {differ} px diffèrent (unités {:.1} / {:.1})", pf.unit, pi.unit);- assert!(differ as f32 > 0.05 * pf.unit * pf.unit, "{key}: le modèle ne suit pas l'inclinaison ({differ})");+ assert!(differ as f32 > 0.02 * pf.unit * pf.unit, "{key}: le modèle ne suit pas l'inclinaison ({differ})");}}