feat(cursor): move click impact to the cursor settings, for every camera

The zoom pane's per-region "Click impact" becomes a project-wide cursor
setting (`cursor.clickImpact`). A fixed angle still rocks the screen and
the moving camera still recoils. A flat screen, with no 3D camera or
outside any zoom, is now pushed back on each click, on the same tap
curve. A document that had it on a zoom turns the cursor setting on
when opened.

Author: EtienneLescot

crates/compositor/src/frame_geometry.rs

@@ -466,13 +466,8 @@ pub struct ZoomState {
     pub rotation: [f32; 3],
     /// À quel point un préset 3D est installé (0..1) : la force de la région quand elle en porte
     /// un, 0 sinon ; interpolé entre deux régions chaînées, et refermé en milieu de course
-    /// quand leurs présets diffèrent. C'est la porte de `dynamic_tilt`.
+    /// quand leurs présets diffèrent. C'est la porte de `dynamic_tilt` (`tilt_gate`).
     pub tilt: f32,
-    /// Poids de l'impact du clic (0..1) : 1 sur une région qui l'active (`click_impact`),
-    /// interpolé entre deux régions chaînées. Ne suffit pas seul : sous un angle fixe, l'impact
-    /// passe aussi par la porte de `tilt` (`dynamic_tilt`) ; sous la caméra réelle, par son poids
-    /// (l'œil recule, `camera::PRESS`).
-    pub click_impact: f32,
     /// Poids de la caméra réelle (`camera.rs`, 0..1) : la force de la région `follow-cursor`, 0
     /// sinon. Jamais non nul en même temps que `rotation` (cf. la transition chaînée).
     pub camera: f32,
@@ -487,7 +482,6 @@ const IDENTITY_ZOOM: ZoomState = ZoomState {
     focus: [0.5, 0.5],
     rotation: [0.0, 0.0, 0.0],
     tilt: 0.0,
-    click_impact: 0.0,
     camera: 0.0,
     aim: [0.5, 0.5],
     orbit: [0.5, 0.5],
@@ -573,16 +567,6 @@ fn weighted(p: [f32; 2], camera: f32) -> [f32; 2] {
     p.map(|a| 0.5 + (a - 0.5) * camera)
 }
 
-/// 1 si la région active l'impact du clic, 0 sinon. Sous un angle fixe, le clic presse l'écran ;
-/// sous la caméra réelle, l'écran reste immobile et c'est l'œil qui recule.
-fn impact_flag(region: &SceneZoomRegion) -> f32 {
-    if region.click_impact {
-        1.0
-    } else {
-        0.0
-    }
-}
-
 /// Port de `easeConnectedPan` (TS) : cubic-bezier(0.1, 0, 0.2, 1).
 fn ease_connected_pan(t: f32) -> f32 {
     cubic_bezier(0.1, 0.0, 0.2, 1.0, t)
@@ -883,7 +867,6 @@ pub fn zoom_state_in(
             ],
             rotation,
             tilt: lerp(fixed_flag(cur), fixed_flag(next), progress) * crossing,
-            click_impact: lerp(impact_flag(cur), impact_flag(next), progress),
             camera,
             aim: weighted(mix(a.aim, b.aim), camera),
             orbit: weighted(mix(a.orbit, b.orbit), camera),
@@ -902,7 +885,6 @@ pub fn zoom_state_in(
                 focus: resolve_focus(next, t, cursor, clock),
                 rotation: fixed_rotation(next),
                 tilt: fixed_flag(next),
-                click_impact: impact_flag(next),
                 camera,
                 aim: weighted(seen.aim, camera),
                 orbit: weighted(seen.orbit, camera),
@@ -956,7 +938,6 @@ pub fn zoom_state_in(
                 focus: [ease(focus[0]), ease(focus[1])],
                 rotation: lerp_rotation3d([0.0, 0.0, 0.0], fixed_rotation(r), strength),
                 tilt: fixed_flag(r) * strength,
-                click_impact: impact_flag(r),
                 camera,
                 aim: weighted(seen.aim, camera),
                 orbit: weighted(seen.orbit, camera),
@@ -1389,7 +1370,7 @@ pub fn dynamic_tilt(
     strength: f32,
     impact: [f32; 3],
 ) -> [f32; 3] {
-    let gate = smoothstep(PARALLAX_GATE_START, 1.0, strength);
+    let gate = tilt_gate(strength);
     if gate <= 0.0 {
         return [0.0; 3];
     }
@@ -1414,6 +1395,13 @@ pub fn dynamic_tilt(
     clamp_dynamic_tilt(sum).map(|d| d * gate)
 }
 
+/// La porte de `dynamic_tilt` : 0 tant qu'un angle fixe n'est pas installé, 1 une fois en place.
+/// Sur l'écran qu'elle laisse droit, l'impact du clic fait reculer l'écran à la place
+/// (`frame_geometry::plan_frame`) : aucune bascule ne part de l'écran droit.
+pub fn tilt_gate(strength: f32) -> f32 {
+    smoothstep(PARALLAX_GATE_START, 1.0, strength)
+}
+
 /// Durée de l'impact du clic : la fenêtre de `CursorTrack::bounce`, pour que le plan et le
 /// pointeur lisent comme un seul contact.
 pub const CLICK_IMPACT_WINDOW_S: f32 = 0.26;
@@ -1488,9 +1476,9 @@ pub fn click_impact(
     ]
 }
 
-/// Le recul de la caméra réelle au temps `t` : la somme des `tap` des mêmes clics que
-/// `click_impact` (dans la fenêtre du clip, visibles), bornée à [−1, 1], −1 au contact. Sans leur
-/// position : l'écran ne bascule pas, l'œil recule tout droit.
+/// Le recul au temps `t`, celui de l'œil sous la caméra réelle ou celui de l'écran droit : la somme
+/// des `tap` des mêmes clics que `click_impact` (dans la fenêtre du clip, visibles), bornée à
+/// [−1, 1], −1 au contact. Sans leur position : rien ne bascule, tout recule droit.
 pub fn click_press(
     t: f32,
     track: &CursorTrack,
@@ -1615,7 +1603,6 @@ mod zoom_focus_tests {
             rotation: None,
             under_trim: false,
             hide_cursor: false,
-            click_impact: false,
         }
     }
 
@@ -2494,7 +2481,6 @@ mod tilt_tests {
             rotation: rotation.map(Into::into),
             under_trim: false,
             hide_cursor: false,
-            click_impact: false,
         };
         // `follow-cursor` n'incline pas l'écran (caméra réelle, `camera.rs`) : chaînée à un angle
         // fixe, la transition passe par l'écran droit, que ce balayage couvre aussi.
@@ -2902,31 +2888,6 @@ mod tilt_tests {
         }
     }
 
-    #[test]
-    fn the_click_impact_weight_follows_the_region_flag() {
-        let region = |click_impact: bool| SceneZoomRegion {
-            id: "z".into(),
-            clip_index: None,
-            start_sec: 2.0,
-            end_sec: 8.0,
-            scale: 2.0,
-            focus_x: 0.5,
-            focus_y: 0.5,
-            focus_mode: None,
-            rotation: Some("left".into()),
-            under_trim: false,
-            hide_cursor: false,
-            click_impact,
-        };
-        assert_eq!(zoom_state_at(&[region(true)], 5.0, None).click_impact, 1.0);
-        assert_eq!(zoom_state_at(&[region(false)], 5.0, None).click_impact, 0.0);
-        assert_eq!(
-            zoom_state_at(&[region(true)], 0.0, None).click_impact,
-            0.0,
-            "hors région"
-        );
-    }
-
     /// `ZoomState::tilt` : la force pour une région à préset, 0 sans préset.
     #[test]
     fn the_tilt_gate_follows_the_region_strength_only_with_a_preset() {
@@ -2942,7 +2903,6 @@ mod tilt_tests {
             rotation: rotation.map(Into::into),
             under_trim: false,
             hide_cursor: false,
-            click_impact: false,
         };
         assert_eq!(zoom_state_at(&[region(Some("left"))], 5.0, None).tilt, 1.0);
         assert_eq!(zoom_state_at(&[region(None)], 5.0, None).tilt, 0.0);
@@ -3249,7 +3209,6 @@ mod follow_camera_tests {
             rotation: Some(rotation.into()),
             under_trim: false,
             hide_cursor: false,
-            click_impact: true,
         }
     }
 
@@ -3278,17 +3237,16 @@ mod follow_camera_tests {
 
     /// Sous `follow-cursor`, l'écran n'est pas incliné et ne glisse pas (focus au centre, quel que
     /// soit le réglage de la région) : seule la caméra, de poids la force de la région, vise et
-    /// tourne avec le pointeur. L'impact du clic passe (l'œil recule). Hors région, l'état plat
-    /// exact.
+    /// tourne avec le pointeur. Hors région, l'état plat exact.
     #[test]
     fn follow_cursor_rides_the_zoom_envelope() {
         let tr = track(|_| (0.85, 0.5));
         let f = whole(&tr);
         let r = [region("follow-cursor", 2.0, 8.0)];
         let full = zoom_state_in(&r, 5.0, Some(&tr), &f, &ScreenClock::default());
         assert_eq!(
-            (full.rotation, full.tilt, full.click_impact, full.camera),
-            ([0.0; 3], 0.0, 1.0, 1.0)
+            (full.rotation, full.tilt, full.camera),
+            ([0.0; 3], 0.0, 1.0)
         );
         assert_eq!((full.scale, full.focus), (2.0, [0.5, 0.5]));
         assert!(
@@ -3326,7 +3284,7 @@ mod follow_camera_tests {
         assert_eq!((blind.aim, blind.orbit), ([0.5, 0.5], [0.5, 0.5]));
         // Un angle fixe garde exactement son état.
         let left = zoom_state_in(&[region("left", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());
-        assert_eq!((left.rotation, left.camera, left.click_impact), ([-12.0, -18.0, -2.0], 0.0, 1.0));
+        assert_eq!((left.rotation, left.camera), ([-12.0, -18.0, -2.0], 0.0));
         let unknown = zoom_state_in(&[region("orbit", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());
         assert_eq!((unknown.rotation, unknown.tilt, unknown.camera), ([0.0; 3], 0.0, 0.0));
     }

crates/compositor/src/regions.rs

@@ -490,11 +490,6 @@ pub struct SceneZoomRegion {
     /// Masque le curseur pendant cette région de zoom.
     #[serde(default)]
     pub hide_cursor: bool,
-    /// Chaque clic enfonce le plan incliné (`regions::click_impact`). Sans effet hors préset
-    /// 3D : c'est le préset qui installe le plan que le clic fait basculer.
-    /// `#[serde(default)]` : l'app omet la clé quand elle est fausse.
-    #[serde(default)]
-    pub click_impact: bool,
 }
 
 /// Une zone de vitesse portée par le temps source d'un clip.
@@ -540,6 +535,12 @@ pub struct SceneCursor {
     /// projets et des JSON écrits avant le réglage, qui gardent donc le curseur plat.
     #[serde(default)]
     pub model3d: bool,
+    /// Chaque clic donne un impact à l'écran, quelle que soit la caméra : sous un angle fixe le
+    /// plan bascule du côté cliqué (`regions::click_impact`), sous la caméra réelle l'œil recule,
+    /// sur un écran droit l'écran recule (`frame_geometry::plan_frame`).
+    /// `#[serde(default)]` : l'app omet la clé quand elle est fausse.
+    #[serde(default)]
+    pub click_impact: bool,
     pub clip_to_bounds: bool,
     /// id du thème (jeu de sprites) — informatif ici : le natif consomme `cursor_sprites`.
     pub theme: String,

crates/compositor/src/scene.rs

@@ -1,5 +1,6 @@
-//! Sous un préset 3D avec « Click impact », un clic fait basculer le plan du côté cliqué puis le
-//! laisse revenir (`regions::click_impact`). Rend de vraies frames par le compositeur D3D11.
+//! Avec « Click impact » (réglage du curseur), un clic fait basculer le plan d'un préset 3D du
+//! côté cliqué puis le laisse revenir (`regions::click_impact`) ; sans préset, il fait reculer
+//! l'écran droit. Rend de vraies frames par le compositeur D3D11.
 //!
 //! Même harnais que `tilt_parallax_render.rs`, mêmes variables d'environnement : une source
 //! 1920×1080 de 6 s, de préférence quadrillée. La piste curseur (immobile, un clic) est écrite
@@ -40,20 +41,20 @@ fn write_sidecar(path: &std::path::Path) {
     std::fs::write(path, format!(r#"{{"samples":[{}]}}"#, samples.join(","))).expect("sidecar");
 }
 
-fn scene_json(source: &str, click_impact: bool) -> String {
+fn scene_json(source: &str, rotation: &str, click_impact: bool) -> String {
     let s = source.replace('\\', "/");
-    let flag = if click_impact { r#","clickImpact":true"# } else { "" };
+    let flag = if click_impact { r#""clickImpact":true,"# } else { "" };
     format!(
         r##"{{
         "clips": [{{"screenPath":"{s}","webcamPath":"","sourceStartSec":0,"sourceEndSec":6,"webcamOffsetSec":0,"hasAudio":false}}],
         "layout": {{"preset":"no-webcam","webcamSize":1.0,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,
                     "screenRect":{{"x":0.15,"y":0.15,"width":0.7,"height":0.7}}}},
         "effects": {{"padding":0.1,"blur":false,"shadow":0.5,"roundnessFrac":0.02,"motionBlur":0.0}},
         "background": {{"kind":"color","color":"#2060d0"}},
-        "zoomRegions": [{{"id":"z","startSec":0,"endSec":6,"scale":1.15,"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"iso"{flag}}}],
+        "zoomRegions": [{{"id":"z","startSec":0,"endSec":6,"scale":1.15,"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"{rotation}"}}],
         "annotations": [],
         "speedRegions": [],
-        "cursor": {{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+        "cursor": {{{flag}"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
         "cropByClip": [null],
         "output": {{"width":{W},"height":{H},"fps":null}}
     }}"##
@@ -116,8 +117,8 @@ fn a_click_presses_the_clicked_side_of_the_tilted_plane() {
     let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
     comp.set_cursor(track.smoothed(0.0));
 
-    let render = |click_impact: bool, t: f64| -> Vec<u8> {
-        let scene = Scene::from_json(&scene_json(&source, click_impact)).expect("scene valide");
+    let render = |rotation: &str, click_impact: bool, t: f64| -> Vec<u8> {
+        let scene = Scene::from_json(&scene_json(&source, rotation, click_impact)).expect("scene valide");
         comp.set_live_params(live_params_from_scene(&scene));
         comp.set_scene(Some(scene));
         unsafe {
@@ -141,15 +142,15 @@ fn a_click_presses_the_clicked_side_of_the_tilted_plane() {
     };
     let mut frames = Vec::new();
     for (name, t) in instants {
-        let rgba = render(true, t);
+        let rgba = render("iso", true, t);
         if let Some(dir) = &out_dir {
             write_ppm(&dir.join(format!("click-{name}.ppm")), &rgba);
         }
         let (l, r, hr, hl) = probe(&rgba);
         println!("{name:<12} t={t:<6} bords {l:>4}..{r:>4}  hauteur droite {hr:>4}  gauche {hl:>4}");
         frames.push((rgba, (l, r, hr, hl)));
     }
-    let off = render(false, CLICK_S + 0.0495);
+    let off = render("iso", false, CLICK_S + 0.0495);
     if let Some(dir) = &out_dir {
         write_ppm(&dir.join("click-off-at-contact.ppm"), &off);
     }
@@ -172,4 +173,17 @@ fn a_click_presses_the_clicked_side_of_the_tilted_plane() {
     assert!(contact.0 < rest.0, "bord gauche {} au repos {}", contact.0, rest.0);
     assert!(contact.2 < rest.2, "hauteur droite {} au repos {}", contact.2, rest.2);
     assert!(contact.3 > rest.3, "hauteur gauche {} au repos {}", contact.3, rest.3);
+
+    // Sans préset, rien ne bascule : l'écran droit recule au contact, les quatre bords rentrent.
+    let flat_rest = render("none", true, CLICK_S - 0.5);
+    let flat_contact = render("none", true, CLICK_S + 0.0495);
+    let flat_off = render("none", false, CLICK_S + 0.0495);
+    if let Some(dir) = &out_dir {
+        write_ppm(&dir.join("click-flat-contact.ppm"), &flat_contact);
+    }
+    let (rest, contact) = (probe(&flat_rest), probe(&flat_contact));
+    println!("écran droit : repos {rest:?}, contact {contact:?}");
+    assert_eq!(silhouette_diff(&flat_off, &flat_rest), 0, "sans l'option, le clic ne doit rien changer");
+    assert!(contact.0 > rest.0 && contact.1 < rest.1, "bords {contact:?} au repos {rest:?}");
+    assert!(contact.2 < rest.2 && contact.3 < rest.3, "hauteurs {contact:?} au repos {rest:?}");
 }

crates/compositor/tests/click_impact_render.rs

@@ -380,7 +380,7 @@ fn orbit_scene(source: &str, regions: &str, (w, h): (u32, u32)) -> Scene {
             "background":{{"kind":"gradient","angleDeg":135,"stops":["#3b4fd1","#c86fa6"]}},
             "zoomRegions":[{regions}],
             "annotations":[],
-            "cursor":{{"show":true,"size":2.2,"smoothing":0,"motionBlur":0,"clickBounce":2.5,"model3d":true,"clipToBounds":false,"theme":"default",
+            "cursor":{{"show":true,"size":2.2,"smoothing":0,"motionBlur":0,"clickBounce":2.5,"model3d":true,"clickImpact":true,"clipToBounds":false,"theme":"default",
                        "cursorSprites":{{"arrow":{{"path":"{arrow}","hotspotX":0.1205,"hotspotY":0.0881}}}}}},
             "cropByClip":[null],
             "output":{{"width":{w},"height":{h},"fps":30}}}}"##
@@ -390,7 +390,7 @@ fn orbit_scene(source: &str, regions: &str, (w, h): (u32, u32)) -> Scene {
 
 fn orbit_region(start: f32, end: f32, scale: f32) -> String {
     format!(
-        r#"{{"clipIndex":0,"startSec":{start},"endSec":{end},"scale":{scale},"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"follow-cursor","clickImpact":true}}"#
+        r#"{{"clipIndex":0,"startSec":{start},"endSec":{end},"scale":{scale},"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"follow-cursor"}}"#
     )
 }
 

crates/compositor/tests/follow_camera_render.rs

@@ -25,6 +25,17 @@ deux effets qui partagent un unique budget d'angle dynamique (`DYNAMIC_TILT_BUDG
 `rotated_quad_corners_px(w, h, base, dyn)` projette les coins ; l'échelle de containment est
 calculée sur la **base seule** (« échelle gelée »), la part dynamique ne fait que reprojeter.
 
+**L'impact du clic est un réglage du curseur** (`cursor.clickImpact`, « Click impact » dans le
+panneau du curseur, éteint par défaut), pas une option de zoom : il vaut sous **toutes** les
+caméras, dans une région de zoom ou hors d'elle. Chaque caméra le rend à sa façon : l'angle fixe
+bascule du côté cliqué (ci-dessus), la caméra mobile recule l'œil (A.3), et l'écran droit
+**recule** : sa boîte rapetisse autour de son centre de `camera::PRESS` au contact (−3,8 %), sur la
+même courbe `tap()`, puis revient (`frame_geometry::plan_frame`). Pas de bascule depuis l'écran
+droit : elle mettrait des arêtes sur les axes (règle des 2°). Le recul prend le complément de la
+porte des angles fixes (`regions::tilt_gate`) et du poids de la caméra mobile, donc les trois se
+relaient sans saut pendant les transitions. Un document qui portait `clickImpact` sur un zoom
+allume le réglage du curseur à son ouverture (`liftZoomClickImpact`).
+
 ### A.2 Le modèle : une seule liste « caméra 3D »
 
 **Révisé trois fois après test produit.** La première version séparait l'attitude
@@ -121,8 +132,8 @@ d'azimut (`CAMERA_LIGHT_GAIN`, 0,5 donnait ±10 % avec l'œil en orbite).
 **Impact du clic** : l'écran reste immobile, c'est **l'œil qui recule** de 4 % de sa distance au
 contact, sur la courbe `tap()` de l'impact des angles fixes (mêmes clics, mêmes portes : fenêtre du
 clip, clic visible, masque, vitesse, opacité du curseur), puis revient avec un léger rebond. Sur la
-vidéo, l'écran perd 2 à 3 % de taille pendant deux images : un tapotement, pas un saut. Le panneau
-l'active sous cette caméra, avec sa propre description.
+vidéo, l'écran perd 2 à 3 % de taille pendant deux images : un tapotement, pas un saut. C'est le
+réglage « Click impact » du curseur, le même sous toutes les caméras (A.1).
 
 Chaînée à un angle fixe, une région `follow-cursor` ne mélange jamais les deux modèles : la
 transition passe par l'écran droit à mi-course. Entre deux régions `follow-cursor`, le cadreur ne

docs/3d-effects-v2.md

@@ -33,6 +33,7 @@ const APPEARANCE: StylePresetAppearance = {
 		clickBounce: 1,
 		model3d: false,
 		alwaysArrow: false,
+		clickImpact: false,
 	},
 	cursorShow: true,
 	cursorAutoHide: false,

electron/ai-edition/style-preset-service.test.ts

@@ -53,6 +53,7 @@ const APPEARANCE: StylePresetAppearance = {
 		clickBounce: 1,
 		model3d: false,
 		alwaysArrow: false,
+		clickImpact: false,
 	},
 	cursorShow: true,
 	cursorAutoHide: false,

electron/ipc/nativeBridge.presets.test.ts

@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { cleanup, render, screen } from "@testing-library/react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { I18nProvider } from "@/contexts/I18nContext";
 import { LOCALE_STORAGE_KEY } from "@/i18n/config";
@@ -62,3 +62,22 @@ describe("CursorPane size", () => {
 		expect([slider.min, slider.max, slider.value]).toEqual(["1.5", "6", "4.5"]);
 	});
 });
+
+describe("CursorPane click impact", () => {
+	const toggle = () => screen.queryByRole("button", { name: "Click impact" });
+
+	it("is a project-wide switch, off by default", () => {
+		renderWithCursor({});
+		expect(toggle()?.getAttribute("aria-pressed")).toBe("false");
+		fireEvent.click(toggle() as HTMLElement);
+		expect(useProjectStore.getState().document?.legacyEditor).toMatchObject({
+			cursorClickImpact: true,
+		});
+	});
+
+	// The impact follows the pointer you see: with the cursor hidden it has nothing to show.
+	it("is not offered while the cursor is hidden", () => {
+		renderWithCursor({ cursorShow: false });
+		expect(toggle()).toBeNull();
+	});
+});