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): cache the follow view per region, settle past the last sample, time the ease-in on screen
EtienneLescot629542703f56
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rsindex 2b44e5d75..0301e2b53 100644--- a/crates/compositor/src/cursor.rs+++ b/crates/compositor/src/cursor.rs@@ -48,8 +48,16 @@ pub struct CursorTrack {/// `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, é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);+/// 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() {@@ -67,7 +75,11 @@ fn sample_at(samples: &[(f32, f32, f32)], t: f32) -> Option<(f32, f32)> {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 };+ 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))}@@ -119,11 +131,24 @@ 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 {+ pub(crate) fn new(+ samples: Vec<(f32, f32, f32)>,+ clicks: Vec<f32>,+ types: Vec<(f32, String)>,+ ) -> 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, types }+ 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,+ types,+ view_cache: Default::default(),+ }}/// État du curseur au temps `t` : la dernière transition à `t` ou avant. `None` avant la@@ -166,7 +191,10 @@ impl CursorTrack {// (`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"),+ 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) {@@ -196,25 +224,64 @@ impl CursorTrack {/// `(t0, t)`, donc la même en preview et à l'export, en lecture comme après un seek. Le coût/// suit la durée de la région, pas celle de la piste.pub fn follow_in_view(&self, t0: f32, t: f32, scale: f32) -> Option<(f32, f32)> {+ let states = self.view_states(t0, 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 de la vue `(t, x, y)` depuis `t0` : l'état de départ, puis un par échantillon+ /// après `t0`. Rejoués une fois par `(t0, échelle)` et gardés : une région en demande un par+ /// frame, et les rejouer depuis `t0` à chaque fois coûtait la longueur de la région.+ fn view_states(&self, t0: f32, scale: f32) -> Option<std::sync::Arc<Vec<(f32, f32, f32)>>> {+ let key = (t0.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 at, mut view) = (t0, (reach(x0), reach(y0)));+ 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);for &(ts, x, y) in &self.samples[first..] {- let (nx, ny) = follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);- let next = (reach(nx), reach(ny));- if ts >= t {- // Entre deux échantillons, linéaire, comme `follow_at`.- let f = if ts > at { ((t - at) / (ts - at)).clamp(0.0, 1.0) } else { 1.0 };- return Some((view.0 + (next.0 - view.0) * f, view.1 + (next.1 - view.1) * f));- }- (at, view) = (ts, next);+ 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));}- Some(view)+ 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@@ -234,7 +301,9 @@ impl CursorTrack {/// l'emporte. 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.clicks.partition_point(|&tc| tc <= t - PIN_HOLD_S - PIN_RELEASE_S);+ 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);for i in lo..hi.max(lo) {let d = t - self.clicks[i];@@ -244,16 +313,27 @@ impl CursorTrack {1.0 - smoothstep01((d - PIN_HOLD_S) / 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) };+ (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))> + '_ {+ 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())+ 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 :@@ -267,7 +347,9 @@ impl CursorTrack {pub fn bounce(&self, t: f32) -> f32 {const ANIM_S: f32 = 0.26; // 260 msconst PRESS_FRAC: f32 = 0.38;- let Some(tc) = self.last_click_at(t) else { return 1.0 };+ 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;@@ -276,7 +358,8 @@ impl CursorTrack {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();+ let rebound =+ ((elapsed - PRESS_FRAC) / (1.0 - PRESS_FRAC) * std::f32::consts::PI).sin();1.0 + rebound * 0.16}}@@ -307,7 +390,11 @@ impl CursorTrack {/// 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(self.samples.clone(), self.clicks.clone(), self.types.clone());+ return CursorTrack::new(+ self.samples.clone(),+ self.clicks.clone(),+ self.types.clone(),+ );}const STEP_S: f32 = 1.0 / 240.0;let start = self.samples[0].0;@@ -318,7 +405,11 @@ impl CursorTrack {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 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);@@ -327,7 +418,12 @@ impl CursorTrack {let (stiffness, damping, mass) = cursor_spring_config(factor);let xs = spring_smooth(&raw_x, stiffness, damping, mass, STEP_S);let ys = spring_smooth(&raw_y, stiffness, damping, mass, STEP_S);- let samples = times.into_iter().zip(xs).zip(ys).map(|((t, x), y)| (t, x, y)).collect();+ 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.@@ -365,7 +461,11 @@ impl CursorTrack {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 };+ let mut arrival_t = if idx > 0 {+ self.samples[idx - 1].0+ } else {+ start_t+ };if idx > 0 {let mut i = idx - 1;@@ -417,7 +517,13 @@ impl CursorTrack {/// 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> {+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;@@ -456,19 +562,91 @@ mod tests {/// 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, 2.0);+ }+ for t in times {+ assert_eq!(+ cached.follow_in_view(0.4, t, 2.0),+ make().follow_in_view(0.4, t, 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, 3.0),+ cached.follow_in_view(0.4, 3.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, 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![])+ 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, 2.0).unwrap();- assert!((x - 0.5).abs() < 1e-6 && (y - 0.5).abs() < 1e-6, "t {} : {x}", i as f32 / 10.0);+ 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()));+ 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.@@ -476,7 +654,10 @@ mod tests {let settled = jump.follow_in_view(0.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, 2.0).unwrap().0;- assert!(early > 0.5 && early < settled, "rattrapage progressif : {early}");+ assert!(+ early > 0.5 && early < settled,+ "rattrapage progressif : {early}"+ );// Une pure fonction de (t0, t) : l'ordre des appels ne change rien.assert_eq!(jump.follow_in_view(0.0, 2.1, 2.0).unwrap().0, early);}@@ -488,14 +669,30 @@ mod tests {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())],+ 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(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");+ 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@@ -585,8 +782,14 @@ mod tests {}// 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:?}");+ 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:?}");}@@ -613,9 +816,21 @@ mod tests {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));+ 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));@@ -627,18 +842,26 @@ mod tests {// 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");+ 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![],- );+ 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);@@ -648,7 +871,13 @@ mod tests {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![+ (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![],);@@ -659,7 +888,10 @@ mod tests {// Entre 1.5s et 1.8s, estompage linéairelet op_mid = track.opacity_at(1.65, true);- assert!((op_mid - 0.5).abs() < 0.05, "mi-parcours d'estompage: {op_mid}");+ assert!(+ (op_mid - 0.5).abs() < 0.05,+ "mi-parcours d'estompage: {op_mid}"+ );// À 1.8s et au-delà, opacité 0.0assert_eq!(track.opacity_at(1.8, true), 0.0);diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rsindex 76b9a7d97..1405ffb2c 100644--- a/crates/compositor/src/regions.rs+++ b/crates/compositor/src/regions.rs@@ -84,7 +84,10 @@ pub fn speed_segments_for_window(/// région seulement si `clip_index` est absent (vieux payload) OU vaut `active_clip_index`.pub fn speed_at(regions: &[SceneSpeedRegion], active_clip_index: usize, t: f64) -> f64 {for region in regions {- let belongs = region.clip_index.map(|i| i == active_clip_index).unwrap_or(true);+ let belongs = region+ .clip_index+ .map(|i| i == active_clip_index)+ .unwrap_or(true);if belongs && t >= region.start_sec && t < region.end_sec {if region.speed.is_finite() && region.speed > 0.0 {return region.speed;@@ -140,7 +143,11 @@ impl ProgrammeClock {.flat_map(&segments_of).map(|s| s.frame_count).sum();- Some(Self { frames_before, segments: segments_of(clip_index), fps })+ Some(Self {+ frames_before,+ segments: segments_of(clip_index),+ fps,+ })}/// Temps programme au temps source `source_sec` du clip. Borné à la fenêtre du clip :@@ -182,7 +189,11 @@ impl ScreenClock {.iter().filter(|r| r.clip_index.map(|i| i == clip_index).unwrap_or(true)).map(|r| {- let speed = if r.speed.is_finite() && r.speed > 0.0 { r.speed } else { 1.0 };+ let speed = if r.speed.is_finite() && r.speed > 0.0 {+ r.speed+ } else {+ 1.0+ };(r.start_sec, r.end_sec, speed)}).collect();@@ -247,7 +258,12 @@ fn push_speed_segment(let frames = (((duration - SPEED_FRAME_EPSILON_SEC) / speed) * fps).ceil().max(0.0) as u64;- spans.push(SpeedSegment { start_sec, end_sec, speed, frame_count: frames });+ spans.push(SpeedSegment {+ start_sec,+ end_sec,+ speed,+ frame_count: frames,+ });}// mêmes fenêtres de transition que le web (TRANSITION_WINDOW_MS etc., converties en secondes).@@ -408,10 +424,12 @@ pub fn zoom_cursor_alpha(regions: &[SceneZoomRegion], t: f32, clock: &ScreenCloc// chaîné ci-dessus.let mut best: Option<(usize, f32)> = None;for (i, r) in regions.iter().enumerate() {- let outgoing_past_end =- pairs.iter().any(|&(ci, _, _, _)| ci == i && t > regions[i].end_sec as f32);- let incoming_before_transition_end =- pairs.iter().any(|&(_, ni, _, t_end)| ni == i && screen_t < t_end);+ let outgoing_past_end = pairs+ .iter()+ .any(|&(ci, _, _, _)| ci == i && t > regions[i].end_sec as f32);+ let incoming_before_transition_end = pairs+ .iter()+ .any(|&(_, ni, _, t_end)| ni == i && screen_t < t_end);if outgoing_past_end || incoming_before_transition_end {continue;}@@ -526,12 +544,20 @@ fn fixed_rotation(region: &SceneZoomRegion) -> [f32; 3] {/// 1 si la région porte un angle fixe, 0 sinon : la porte de la parallaxe et de l'impact.fn fixed_flag(region: &SceneZoomRegion) -> f32 {- if matches!(camera_for(®ion.rotation), Camera::Fixed(_)) { 1.0 } else { 0.0 }+ if matches!(camera_for(®ion.rotation), Camera::Fixed(_)) {+ 1.0+ } else {+ 0.0+ }}/// 1 si la région porte la caméra réelle, 0 sinon.fn follow_flag(region: &SceneZoomRegion) -> f32 {- if camera_for(®ion.rotation) == Camera::Follow { 1.0 } else { 0.0 }+ if camera_for(®ion.rotation) == Camera::Follow {+ 1.0+ } else {+ 0.0+ }}/// Ce que la caméra d'une région lit à `t` (le centre hors `follow-cursor`), non pondéré.@@ -550,7 +576,11 @@ fn weighted(p: [f32; 2], camera: f32) -> [f32; 2] {/// 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 }+ if region.click_impact {+ 1.0+ } else {+ 0.0+ }}/// Port de `easeConnectedPan` (TS) : cubic-bezier(0.1, 0, 0.2, 1).@@ -596,7 +626,11 @@ fn rotation3d_for(rotation: &Option<String>) -> [f32; 3] {}fn lerp_rotation3d(a: [f32; 3], b: [f32; 3], t: f32) -> [f32; 3] {- [lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t)]+ [+ lerp(a[0], b[0], t),+ lerp(a[1], b[1], t),+ lerp(a[2], b[2], t),+ ]}/// Les trois segments d'une flèche d'annotation, en unités du viewBox SVG (0..100), repris@@ -605,19 +639,47 @@ fn lerp_rotation3d(a: [f32; 3], b: [f32; 3], t: f32) -> [f32; 3] {/// flèche — inutile de réinventer une géométrie « équivalente ».pub fn arrow_segments_viewbox(direction: &str) -> [[f32; 4]; 3] {match direction {- "up" => [[50.0, 20.0, 50.0, 80.0], [50.0, 20.0, 35.0, 35.0], [50.0, 20.0, 65.0, 35.0]],- "down" => [[50.0, 20.0, 50.0, 80.0], [50.0, 80.0, 35.0, 65.0], [50.0, 80.0, 65.0, 65.0]],- "left" => [[80.0, 50.0, 20.0, 50.0], [20.0, 50.0, 35.0, 35.0], [20.0, 50.0, 35.0, 65.0]],- "up-right" => [[25.0, 75.0, 75.0, 25.0], [75.0, 25.0, 53.8, 25.0], [75.0, 25.0, 75.0, 46.2]],- "up-left" => [[75.0, 75.0, 25.0, 25.0], [25.0, 25.0, 25.0, 46.2], [25.0, 25.0, 46.2, 25.0]],- "down-right" => {- [[25.0, 25.0, 75.0, 75.0], [75.0, 75.0, 75.0, 53.8], [75.0, 75.0, 53.8, 75.0]]- }- "down-left" => {- [[75.0, 25.0, 25.0, 75.0], [25.0, 75.0, 46.2, 75.0], [25.0, 75.0, 25.0, 53.8]]- }+ "up" => [+ [50.0, 20.0, 50.0, 80.0],+ [50.0, 20.0, 35.0, 35.0],+ [50.0, 20.0, 65.0, 35.0],+ ],+ "down" => [+ [50.0, 20.0, 50.0, 80.0],+ [50.0, 80.0, 35.0, 65.0],+ [50.0, 80.0, 65.0, 65.0],+ ],+ "left" => [+ [80.0, 50.0, 20.0, 50.0],+ [20.0, 50.0, 35.0, 35.0],+ [20.0, 50.0, 35.0, 65.0],+ ],+ "up-right" => [+ [25.0, 75.0, 75.0, 25.0],+ [75.0, 25.0, 53.8, 25.0],+ [75.0, 25.0, 75.0, 46.2],+ ],+ "up-left" => [+ [75.0, 75.0, 25.0, 25.0],+ [25.0, 25.0, 25.0, 46.2],+ [25.0, 25.0, 46.2, 25.0],+ ],+ "down-right" => [+ [25.0, 25.0, 75.0, 75.0],+ [75.0, 75.0, 75.0, 53.8],+ [75.0, 75.0, 53.8, 75.0],+ ],+ "down-left" => [+ [75.0, 25.0, 25.0, 75.0],+ [25.0, 75.0, 46.2, 75.0],+ [25.0, 75.0, 25.0, 53.8],+ ],// "right" et tout ce qui n'est pas reconnu — même défaut que le schéma côté app.- _ => [[20.0, 50.0, 80.0, 50.0], [80.0, 50.0, 65.0, 35.0], [80.0, 50.0, 65.0, 65.0]],+ _ => [+ [20.0, 50.0, 80.0, 50.0],+ [80.0, 50.0, 65.0, 35.0],+ [80.0, 50.0, 65.0, 65.0],+ ],}}@@ -634,7 +696,10 @@ pub fn arrow_local_geometry(quad_px: [f32; 2],) -> ([[f32; 4]; 3], f32) {let scale = quad_px[0].min(quad_px[1]) / 100.0;- let off = [(quad_px[0] - 100.0 * scale) * 0.5, (quad_px[1] - 100.0 * scale) * 0.5];+ let off = [+ (quad_px[0] - 100.0 * scale) * 0.5,+ (quad_px[1] - 100.0 * scale) * 0.5,+ ];let to_local = |v: [f32; 4]| {[off[0] + v[0] * scale,@@ -645,13 +710,25 @@ pub fn arrow_local_geometry(};let segments = arrow_segments_viewbox(direction);let half_stroke = (stroke_width_viewbox.max(0.0) * scale) * 0.5;- ([to_local(segments[0]), to_local(segments[1]), to_local(segments[2])], half_stroke)+ (+ [+ to_local(segments[0]),+ to_local(segments[1]),+ to_local(segments[2]),+ ],+ half_stroke,+ )}/// Focus effectif d'une région à `t` : sa position fixe, sauf en mode "auto" où elle suit la/// télémétrie curseur (port de `getResolvedFocus`, sans le clamp — le crop-window de/// `compositor.rs` clampe déjà après coup, cf. `su0.clamp(...)`, donc redondant ici).-fn resolve_focus(region: &SceneZoomRegion, t: f32, cursor: Option<&CursorTrack>) -> [f32; 2] {+fn resolve_focus(+ region: &SceneZoomRegion,+ t: f32,+ cursor: Option<&CursorTrack>,+ clock: &ScreenClock,+) -> [f32; 2] {// Sous la caméra réelle, le cadrage vient de son pivot : la boîte zoome sur son centre, sans// glissement 2D. Chaînée à une région plate, la transition glisse donc vers le focus de// celle-ci sans saut.@@ -663,8 +740,10 @@ fn resolve_focus(region: &SceneZoomRegion, t: f32, cursor: Option<&CursorTrack>)// La piste LISSÉE, avec une zone morte au centre de la vue zoomée (`follow_in_view`) :// la vue ne bouge que quand le pointeur en sort. Suivre la télémétrie brute, ou chaque// petit geste, donne un pan nerveux. Le filtre part du début de l'ease-in de la région,- // un instant fixe : preview et export rejouent la même chose.- let t0 = region.start_sec as f32 - zoom_transition_s(region.scale);+ // un instant fixe : preview et export rejouent la même chose. L'ease-in se mesure à+ // l'écran (`zoom_region_strength`), son début se ramène donc à la source par l'horloge.+ let window = zoom_transition_s(region.scale);+ let t0 = clock.source_at(clock.at(region.start_sec as f32) - window);if let Some((cx, cy)) = track.follow_in_view(t0, t, region.scale) {return [cx, cy];}@@ -684,16 +763,31 @@ fn resolve_focus(region: &SceneZoomRegion, t: f32, cursor: Option<&CursorTrack>)/// rendu, donc un pan lissé vers (ou depuis) l'une d'elles ferait bouger des frames gardées au/// nom d'une région que l'export ne joue pas. Elles restent des régions dominantes indépendantes,/// sèches sur leur propre span (cf. `zoom_region_strength`).-fn connected_pairs(regions: &[SceneZoomRegion], clock: &ScreenClock) -> Vec<(usize, usize, f32, f32)> {- let mut order: Vec<usize> = (0..regions.len()).filter(|&i| !regions[i].under_trim).collect();- order.sort_by(|&a, &b| regions[a].start_sec.partial_cmp(®ions[b].start_sec).unwrap());+fn connected_pairs(+ regions: &[SceneZoomRegion],+ clock: &ScreenClock,+) -> Vec<(usize, usize, f32, f32)> {+ let mut order: Vec<usize> = (0..regions.len())+ .filter(|&i| !regions[i].under_trim)+ .collect();+ order.sort_by(|&a, &b| {+ regions[a]+ .start_sec+ .partial_cmp(®ions[b].start_sec)+ .unwrap()+ });let mut pairs = Vec::new();for w in order.windows(2) {let (ci, ni) = (w[0], w[1]);let transition_start = clock.at(regions[ci].end_sec as f32);let gap = clock.at(regions[ni].start_sec as f32) - transition_start;if gap <= CHAINED_ZOOM_PAN_GAP_S {- pairs.push((ci, ni, transition_start, transition_start + CONNECTED_ZOOM_PAN_DURATION_S));+ pairs.push((+ ci,+ ni,+ transition_start,+ transition_start + CONNECTED_ZOOM_PAN_DURATION_S,+ ));}}pairs@@ -701,8 +795,18 @@ fn connected_pairs(regions: &[SceneZoomRegion], clock: &ScreenClock) -> Vec<(usi/// `zoom_state_in` sans speed region ni caméra `follow-cursor` : ce que les tests comparent.#[cfg(test)]-pub fn zoom_state_at(regions: &[SceneZoomRegion], t: f32, cursor: Option<&CursorTrack>) -> ZoomState {- zoom_state_in(regions, t, cursor, &CameraFrame::NONE, &ScreenClock::default())+pub fn zoom_state_at(+ regions: &[SceneZoomRegion],+ t: f32,+ cursor: Option<&CursorTrack>,+) -> ZoomState {+ zoom_state_in(+ regions,+ t,+ cursor,+ &CameraFrame::NONE,+ &ScreenClock::default(),+ )}/// État de zoom au temps `t` (secondes source du clip actif). Port de@@ -733,16 +837,19 @@ pub fn zoom_state_in(let progress =ease_connected_pan(clamp01((screen_t - t_start) / (t_end - t_start).max(1e-3)));let (cur, next) = (®ions[ci], ®ions[ni]);- let cur_focus = resolve_focus(cur, t, cursor);- let next_focus = resolve_focus(next, t, cursor);+ let cur_focus = resolve_focus(cur, t, cursor, clock);+ let next_focus = resolve_focus(next, t, cursor, clock);// Entre deux présets DIFFÉRENTS, la base traverse des poses qu'aucun préset ne valide// (left→right passe par Y = 0) : la marge que l'échelle gelée laissait au budget n'y est// plus. La porte se ferme donc en milieu de course et ne se rouvre qu'au ras des bouts —// 1 − 4p(1−p) vaut 1 en p = 0 et p = 1, donc aucun saut avec la région d'avant ni avec// le palier d'après. Cf. `the_chained_sweep_keeps_every_edge_off_axis_and_inside`.let (cur_cam, next_cam) = (camera_for(&cur.rotation), camera_for(&next.rotation));- let crossing =- if cur_cam == next_cam { 1.0 } else { 1.0 - 4.0 * progress * (1.0 - progress) };+ let crossing = if cur_cam == next_cam {+ 1.0+ } else {+ 1.0 - 4.0 * progress * (1.0 - progress)+ };// Un angle fixe incline l'écran, la caméra réelle le laisse immobile : les deux modèles ne// se mélangent pas. Entre eux, la transition passe par l'écran droit à mi-course, l'un// s'éteignant sur la première moitié, l'autre s'allumant sur la seconde.@@ -751,9 +858,16 @@ pub fn zoom_state_in((Camera::Follow, Camera::Fixed(_)) | (Camera::Fixed(_), Camera::Follow));let (rotation, camera) = if split {- let (out, into) = ((1.0 - 2.0 * progress).max(0.0), (2.0 * progress - 1.0).max(0.0));+ let (out, into) = (+ (1.0 - 2.0 * progress).max(0.0),+ (2.0 * progress - 1.0).max(0.0),+ );let r = fixed_rotation(cur).map(|a| a * out);- let r = if r == [0.0; 3] { fixed_rotation(next).map(|a| a * into) } else { r };+ let r = if r == [0.0; 3] {+ fixed_rotation(next).map(|a| a * into)+ } else {+ r+ };(r, follow_flag(cur) * out + follow_flag(next) * into)} else {(@@ -762,10 +876,14 @@ pub fn zoom_state_in()};let (a, b) = (follow_at(cur, t, frame), follow_at(next, t, frame));- let mix = |p: [f32; 2], q: [f32; 2]| [lerp(p[0], q[0], progress), lerp(p[1], q[1], progress)];+ let mix =+ |p: [f32; 2], q: [f32; 2]| [lerp(p[0], q[0], progress), lerp(p[1], q[1], progress)];return ZoomState {scale: scale_lerp(cur.scale, next.scale, progress),- focus: [lerp(cur_focus[0], next_focus[0], progress), lerp(cur_focus[1], next_focus[1], progress)],+ focus: [+ lerp(cur_focus[0], next_focus[0], progress),+ lerp(cur_focus[1], next_focus[1], progress),+ ],rotation,tilt: lerp(fixed_flag(cur), fixed_flag(next), progress) * crossing,click_impact: lerp(impact_flag(cur), impact_flag(next), progress),@@ -784,7 +902,7 @@ pub fn zoom_state_in(let seen = follow_at(next, t, frame);return ZoomState {scale: next.scale,- focus: resolve_focus(next, t, cursor),+ focus: resolve_focus(next, t, cursor, clock),rotation: fixed_rotation(next),tilt: fixed_flag(next),click_impact: impact_flag(next),@@ -799,10 +917,12 @@ pub fn zoom_state_in(// chaîné ci-dessus (sinon leur propre ease-in/out "percerait" à travers la fenêtre chaînée).let mut best: Option<(usize, f32)> = None;for (i, r) in regions.iter().enumerate() {- let outgoing_past_end =- pairs.iter().any(|&(ci, _, _, _)| ci == i && t > regions[i].end_sec as f32);- let incoming_before_transition_end =- pairs.iter().any(|&(_, ni, _, t_end)| ni == i && screen_t < t_end);+ let outgoing_past_end = pairs+ .iter()+ .any(|&(ci, _, _, _)| ci == i && t > regions[i].end_sec as f32);+ let incoming_before_transition_end = pairs+ .iter()+ .any(|&(_, ni, _, t_end)| ni == i && screen_t < t_end);if outgoing_past_end || incoming_before_transition_end {continue;}@@ -821,7 +941,7 @@ pub fn zoom_state_in(match best {Some((i, strength)) => {let r = ®ions[i];- let focus = resolve_focus(r, t, cursor);+ let focus = resolve_focus(r, t, cursor, clock);let scale = scale_lerp(1.0, r.scale, strength);// La référence (`zoomTransform.ts`) fait converger le point de focus vers le centre// de l'écran LINÉAIREMENT : screen(f) = 0.5 + (f - 0.5)(1 - strength). Passer@@ -871,13 +991,21 @@ fn camera_fullscreen_region_strength(let lead_in_end = start + lead_in;let lead_out_start = end - lead_out;if t < lead_in_end {- let progress = if lead_in > 0.0 { (t - start) / lead_in } else { 1.0 };+ let progress = if lead_in > 0.0 {+ (t - start) / lead_in+ } else {+ 1.0+ };return ease_out_screen_studio(progress);}if t <= lead_out_start {return 1.0;}- let progress = if lead_out > 0.0 { (end - t) / lead_out } else { 0.0 };+ let progress = if lead_out > 0.0 {+ (end - t) / lead_out+ } else {+ 0.0+ };ease_out_screen_studio(progress)}@@ -939,7 +1067,11 @@ fn rotate_corner(x0: f32, y0: f32, rot: [f32; 3]) -> (f32, f32, f32) {/// caméra) : Z, puis Y, puis X, en degrés. Le curseur modélisé (mode 15) a besoin de points/// hors du plan, et doit tourner exactement comme lui.pub(crate) fn rotate_point(p: [f32; 3], rot: [f32; 3]) -> [f32; 3] {- let (a, b, g) = (rot[0].to_radians(), rot[1].to_radians(), rot[2].to_radians());+ let (a, b, g) = (+ rot[0].to_radians(),+ rot[1].to_radians(),+ rot[2].to_radians(),+ );let (ca, sa) = (a.cos(), a.sin());let (cb, sb) = (b.cos(), b.sin());let (cg, sg) = (g.cos(), g.sin());@@ -962,7 +1094,11 @@ pub(crate) fn rotate_point(p: [f32; 3], rot: [f32; 3]) -> [f32; 3] {/// L'inverse de `rotate_point` : du repère caméra vers celui du plan (X, puis Y, puis Z, chacun/// transposé). Une rotation est orthonormée, sa transposée est son inverse.pub(crate) fn rotate_point_inv(p: [f32; 3], rot: [f32; 3]) -> [f32; 3] {- let (a, b, g) = (rot[0].to_radians(), rot[1].to_radians(), rot[2].to_radians());+ let (a, b, g) = (+ rot[0].to_radians(),+ rot[1].to_radians(),+ rot[2].to_radians(),+ );let (ca, sa) = (a.cos(), a.sin());let (cb, sb) = (b.cos(), b.sin());let (cg, sg) = (g.cos(), g.sin());@@ -986,7 +1122,11 @@ pub(crate) fn rotate_point_inv(p: [f32; 3], rot: [f32; 3]) -> [f32; 3] {/// rotateZ. En développant x1 = x0·cg − y0·sg et y1 = x0·sg + y0·cg, `pz` est linéaire en/// (x0, y0) — d'où ces deux coefficients, sans rien de plus à calculer par pixel.pub(crate) fn depth_coefficients(rot: [f32; 3]) -> (f32, f32) {- let (a, b, g) = (rot[0].to_radians(), rot[1].to_radians(), rot[2].to_radians());+ let (a, b, g) = (+ rot[0].to_radians(),+ rot[1].to_radians(),+ rot[2].to_radians(),+ );let (ca, sa) = (a.cos(), a.sin());let sb = b.sin();let (cg, sg) = (g.cos(), g.sin());@@ -1031,7 +1171,9 @@ fn project_scaled_corners(/// Demi-étendue des coins projetés sur chaque axe.fn projected_extents(corners: &[(f32, f32); 4]) -> (f32, f32) {- corners.iter().fold((0.0f32, 0.0f32), |(mx, my), &(x, y)| (mx.max(x.abs()), my.max(y.abs())))+ corners.iter().fold((0.0f32, 0.0f32), |(mx, my), &(x, y)| {+ (mx.max(x.abs()), my.max(y.abs()))+ })}/// Un écran incliné : ses 4 coins projetés, et la réduction qu'il a fallu pour qu'ils tiennent.@@ -1097,7 +1239,12 @@ pub fn rotated_quad_corners_px(// Un coin derrière le plan de fuite : on rend le quad non tourné plutôt qu'une projection// absurde (même repli qu'avant).return TiltedQuad {- corners: [(-half_w, -half_h), (half_w, -half_h), (half_w, half_h), (-half_w, half_h)],+ corners: [+ (-half_w, -half_h),+ (half_w, -half_h),+ (half_w, half_h),+ (-half_w, half_h),+ ],scale: 1.0,depth_k: (0.0, 0.0),rot: [0.0; 3],@@ -1111,7 +1258,11 @@ pub fn rotated_quad_corners_px(// décollerait du plan pendant la parallaxe.let mut drawn = rot;if rot_dyn != [0.0; 3] {- let full = [rot[0] + rot_dyn[0], rot[1] + rot_dyn[1], rot[2] + rot_dyn[2]];+ let full = [+ rot[0] + rot_dyn[0],+ rot[1] + rot_dyn[1],+ rot[2] + rot_dyn[2],+ ];// Un coin qui passerait derrière le plan de fuite : on garde la pose de base.if let Some(c) = project_scaled_corners(width, height, scale, full, perspective) {corners = c;@@ -1189,7 +1340,11 @@ pub const DYNAMIC_TILT_BUDGET: [f32; 3] = [1.9, 3.0, 0.0];/// Borne une part dynamique au budget, axe par axe.pub fn clamp_dynamic_tilt(rot: [f32; 3]) -> [f32; 3] {let b = DYNAMIC_TILT_BUDGET;- [rot[0].clamp(-b[0], b[0]), rot[1].clamp(-b[1], b[1]), rot[2].clamp(-b[2], b[2])]+ [+ rot[0].clamp(-b[0], b[0]),+ rot[1].clamp(-b[1], b[1]),+ rot[2].clamp(-b[2], b[2]),+ ]}/// Force du préset sous laquelle la part dynamique est nulle ; elle s'installe en smoothstep@@ -1254,7 +1409,11 @@ pub fn dynamic_tilt(}_ => [0.0; 3],};- let sum = [parallax[0] + impact[0], parallax[1] + impact[1], parallax[2] + impact[2]];+ let sum = [+ parallax[0] + impact[0],+ parallax[1] + impact[1],+ parallax[2] + impact[2],+ ];clamp_dynamic_tilt(sum).map(|d| d * gate)}@@ -1314,8 +1473,13 @@ pub fn click_impact(if tc < window[0] || tc >= window[1] {continue;}- let Some([fx, fy]) = track.at(tc).and_then(&aim) else { continue };- let (dx, dy) = ((2.0 * fx - 1.0).clamp(-1.0, 1.0), (2.0 * fy - 1.0).clamp(-1.0, 1.0));+ let Some([fx, fy]) = track.at(tc).and_then(&aim) else {+ continue;+ };+ let (dx, dy) = (+ (2.0 * fx - 1.0).clamp(-1.0, 1.0),+ (2.0 * fy - 1.0).clamp(-1.0, 1.0),+ );let k = tap((t - tc) / CLICK_IMPACT_WINDOW_S);sum[0] += k * dy;sum[1] -= k * dx;@@ -1389,7 +1553,10 @@ impl TiltedQuad {let [tl, tr, br, bl] = self.corners;let top = (tl.0 + (tr.0 - tl.0) * fx, tl.1 + (tr.1 - tl.1) * fx);let bottom = (bl.0 + (br.0 - bl.0) * fx, bl.1 + (br.1 - bl.1) * fx);- (top.0 + (bottom.0 - top.0) * fy, top.1 + (bottom.1 - top.1) * fy)+ (+ top.0 + (bottom.0 - top.0) * fy,+ top.1 + (bottom.1 - top.1) * fy,+ )}/// Le `mb` du draw mode 8 : `[gx, gy, z_focus, k]`.@@ -1410,13 +1577,21 @@ impl TiltedQuad {let gy = screen_px[1] * self.scale * self.depth_k.1;let z_focus = (focus_plane[0] - 0.5) * gx + (focus_plane[1] - 0.5) * gy;let perspective = self.perspective;- let k = if dof && perspective > 0.0 { DOF_COC_PER_DEPTH / perspective } else { 0.0 };+ let k = if dof && perspective > 0.0 {+ DOF_COC_PER_DEPTH / perspective+ } else {+ 0.0+ };[gx, gy, z_focus, k]}/// Le drapeau « warp projectif » des shaders (1) ou bilinéaire (0).pub fn warp_flag(&self) -> f32 {- if self.projective { 1.0 } else { 0.0 }+ if self.projective {+ 1.0+ } else {+ 0.0+ }}/// Demi-largeur / demi-hauteur de la bounding box des coins projetés, en px.@@ -1451,18 +1626,59 @@ mod zoom_focus_tests {/// dernière (ou la première) position suivie au lieu de retomber sur le point statique de la/// région. Sans ça, le plan net sauterait d'un bout de l'écran à l'autre à la fin de la/// télémétrie — et la netteté avec lui, maintenant que `z_focus` en dépend.+ /// Le suivi auto part du début de l'ease-in MESURÉ À L'ÉCRAN : sous un ralenti avant la+ /// région, ce début tombe plus tard en source que `start − fenêtre`.+ #[test]+ fn auto_focus_starts_its_dead_zone_at_the_on_screen_ease_in() {+ let track = CursorTrack::new(+ (0..=240)+ .map(|i| (i as f32 / 30.0, 0.5 + 0.35 * (i as f32 / 15.0).sin(), 0.5))+ .collect(),+ vec![],+ vec![],+ );+ let mut r = region(2.0, 0.5);+ r.focus_mode = Some("auto".into());+ let slow = crate::scene::SceneSpeedRegion {+ clip_index: None,+ start_sec: 0.0,+ end_sec: 2.0,+ speed: 0.5,+ };+ let clock = ScreenClock::new(&[slow], 0);+ let window = zoom_transition_s(r.scale);+ let t0 = clock.source_at(clock.at(r.start_sec as f32) - window);+ assert!(+ t0 > r.start_sec as f32 - window + 0.1,+ "garde : le ralenti doit déplacer le départ ({t0})"+ );+ let (x, y) = track.follow_in_view(t0, 3.0, r.scale).unwrap();+ assert_eq!(resolve_focus(&r, 3.0, Some(&track), &clock), [x, y]);+ }+#[test]fn auto_focus_holds_the_last_tracked_point_past_the_track() {- let track = CursorTrack::new(vec![(3.0, 0.8, 0.2), (4.0, 0.9, 0.1)], Vec::new(), Vec::new());+ let track = CursorTrack::new(+ vec![(3.0, 0.8, 0.2), (4.0, 0.9, 0.1)],+ Vec::new(),+ Vec::new(),+ );let mut r = region(1.5, 0.1);r.focus_mode = Some("auto".into());let t0 = r.start_sec as f32 - zoom_transition_s(r.scale);let last = track.follow_in_view(t0, 4.0, r.scale).unwrap();for t in [4.5f32, 6.0, 7.9] {- assert_eq!(resolve_focus(&r, t, Some(&track)), [last.0, last.1], "t = {t}");+ assert_eq!(+ resolve_focus(&r, t, Some(&track), &ScreenClock::default()),+ [last.0, last.1],+ "t = {t}"+ );}let first = track.follow_in_view(t0, 2.1, r.scale).unwrap();- assert_eq!(resolve_focus(&r, 2.1, Some(&track)), [first.0, first.1]);+ assert_eq!(+ resolve_focus(&r, 2.1, Some(&track), &ScreenClock::default()),+ [first.0, first.1]+ );}#[test]@@ -1475,13 +1691,22 @@ mod zoom_focus_tests {let regions = vec![r];// Bien avant le zoom (t=0.0) -> pleine opacité- assert_eq!(zoom_cursor_alpha(®ions, 0.0, &ScreenClock::default()), 1.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 0.0, &ScreenClock::default()),+ 1.0+ );// Plein milieu du zoom (t=4.5) -> complètement masqué- assert_eq!(zoom_cursor_alpha(®ions, 4.5, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 4.5, &ScreenClock::default()),+ 0.0+ );// Bien après le zoom (t=10.0) -> pleine opacité- assert_eq!(zoom_cursor_alpha(®ions, 10.0, &ScreenClock::default()), 1.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 10.0, &ScreenClock::default()),+ 1.0+ );}#[test]@@ -1499,13 +1724,25 @@ mod zoom_focus_tests {let regions = vec![r1, r2];// Pendant la région 1 (t=3.0) -> masqué- assert_eq!(zoom_cursor_alpha(®ions, 3.0, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 3.0, &ScreenClock::default()),+ 0.0+ );// Pendant la transition chaînée (connected pan entre t=4.0 et t=4.3) -> reste masqué- assert_eq!(zoom_cursor_alpha(®ions, 4.15, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 4.15, &ScreenClock::default()),+ 0.0+ );// Pendant le palier chaîné (t=4.4) -> reste masqué- assert_eq!(zoom_cursor_alpha(®ions, 4.4, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 4.4, &ScreenClock::default()),+ 0.0+ );// Pendant la région 2 (t=5.5) -> masqué- assert_eq!(zoom_cursor_alpha(®ions, 5.5, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 5.5, &ScreenClock::default()),+ 0.0+ );}#[test]@@ -1523,9 +1760,15 @@ mod zoom_focus_tests {let regions = vec![r1, r2];// Avant la transition (r1 actif) -> 0.0- assert_eq!(zoom_cursor_alpha(®ions, 3.0, &ScreenClock::default()), 0.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 3.0, &ScreenClock::default()),+ 0.0+ );// Après la transition (r2 actif avec hide_cursor=false) -> 1.0- assert_eq!(zoom_cursor_alpha(®ions, 5.5, &ScreenClock::default()), 1.0);+ assert_eq!(+ zoom_cursor_alpha(®ions, 5.5, &ScreenClock::default()),+ 1.0+ );}/// Où le point source `f` atterrit à l'écran (0..1) : le crop est centré sur `focus` et@@ -1575,9 +1818,21 @@ mod zoom_focus_tests {.map(|i| speed(lead_in + i as f32 * dt)).fold(0.0f32, f32::max);assert!(peak < 3.0, "{scale}× : pic à {peak}/s");- assert!(speed(lead_in) < 0.1 * peak, "{scale}× : départ à {}/s", speed(lead_in));- assert!(speed(8.0) < 0.1 * peak, "{scale}× : retour à {}/s", speed(8.0));- assert_eq!(zoom_state_at(&r, 2.0, None).scale, scale, "{scale}× en place au début");+ assert!(+ speed(lead_in) < 0.1 * peak,+ "{scale}× : départ à {}/s",+ speed(lead_in)+ );+ assert!(+ speed(8.0) < 0.1 * peak,+ "{scale}× : retour à {}/s",+ speed(8.0)+ );+ assert_eq!(+ zoom_state_at(&r, 2.0, None).scale,+ scale,+ "{scale}× en place au début"+ );}}@@ -1586,7 +1841,11 @@ mod zoom_focus_tests {let f = 0.8;let regions = [region(2.5, f)];let state = zoom_state_at(®ions, 5.0, None);- assert!((state.scale - 2.5).abs() < 1e-4, "plein régime attendu, scale={}", state.scale);+ assert!(+ (state.scale - 2.5).abs() < 1e-4,+ "plein régime attendu, scale={}",+ state.scale+ );assert!((screen_x(&state, f) - 0.5).abs() < 1e-4);assert!((state.focus[0] - f).abs() < 1e-4);}@@ -1626,8 +1885,18 @@ mod zoom_focus_tests {assert!(connected_pairs(&[region(2.0, 0.5), cut], &ScreenClock::default()).is_empty());}- fn speed(clip_index: Option<usize>, start_sec: f64, end_sec: f64, speed: f64) -> SceneSpeedRegion {- SceneSpeedRegion { clip_index, start_sec, end_sec, speed }+ fn speed(+ clip_index: Option<usize>,+ start_sec: f64,+ end_sec: f64,+ speed: f64,+ ) -> SceneSpeedRegion {+ SceneSpeedRegion {+ clip_index,+ start_sec,+ end_sec,+ speed,+ }}#[test]@@ -1637,16 +1906,31 @@ mod zoom_focus_tests {assert_eq!(clock.at(4.0), 2.5);assert_eq!(clock.at(8.0), 5.0);for t in [0.5f32, 2.0, 3.3, 6.0, 7.25] {- assert!((clock.source_at(clock.at(t)) - t).abs() < 1e-5, "aller-retour à t = {t}");+ assert!(+ (clock.source_at(clock.at(t)) - t).abs() < 1e-5,+ "aller-retour à t = {t}"+ );}// Une frame d'écran en arrière depuis une frontière : le pas est celui du span d'AVANT.let back = |t: f32| clock.source_at(clock.at(t) - 1.0 / 60.0);- assert!((back(2.0) - (2.0 - 1.0 / 60.0)).abs() < 1e-5, "entrée du 4× : {}", back(2.0));- assert!((back(6.0) - (6.0 - 4.0 / 60.0)).abs() < 1e-5, "sortie du 4× : {}", back(6.0));+ assert!(+ (back(2.0) - (2.0 - 1.0 / 60.0)).abs() < 1e-5,+ "entrée du 4× : {}",+ back(2.0)+ );+ assert!(+ (back(6.0) - (6.0 - 4.0 / 60.0)).abs() < 1e-5,+ "sortie du 4× : {}",+ back(6.0)+ );// Autre clip ignoré ; recouvrement : la première région garde [4, 6), la seconde ne// compte que sur [6, 8). 2 + 1 + 1 à t = 8.let clock = ScreenClock::new(- &[speed(Some(1), 0.0, 10.0, 2.0), speed(Some(0), 2.0, 6.0, 4.0), speed(Some(0), 4.0, 8.0, 2.0)],+ &[+ speed(Some(1), 0.0, 10.0, 2.0),+ speed(Some(0), 2.0, 6.0, 4.0),+ speed(Some(0), 4.0, 8.0, 2.0),+ ],0,);assert_eq!(clock.at(8.0), 4.0);@@ -1660,21 +1944,37 @@ mod zoom_focus_tests {let clock = ScreenClock::new(&[speed(None, 0.0, 1000.0, 4.0)], 0);let zooms = |k: f64| {let (mut a, mut b) = (region(2.5, 0.8), region(1.8, 0.3));- (a.start_sec, a.end_sec, b.start_sec, b.end_sec) = (5.0 * k, 10.0 * k, 11.0 * k, 15.0 * k);+ (a.start_sec, a.end_sec, b.start_sec, b.end_sec) =+ (5.0 * k, 10.0 * k, 11.0 * k, 15.0 * k);[a, b]};- let full_camera =- |k: f64| [SceneCameraFullscreenRegion { clip_index: None, start_sec: 18.0 * k, end_sec: 22.0 * k }];+ let full_camera = |k: f64| {+ [SceneCameraFullscreenRegion {+ clip_index: None,+ start_sec: 18.0 * k,+ end_sec: 22.0 * k,+ }]+ };let (sped, plain) = (zooms(4.0), zooms(1.0));- assert_eq!(connected_pairs(&sped, &clock).len(), 1, "la paire doit se chaîner");+ assert_eq!(+ connected_pairs(&sped, &clock).len(),+ 1,+ "la paire doit se chaîner"+ );for step in 0..=1000 {let t = step as f32 * 0.1;let a = zoom_state_in(&sped, t, None, &CameraFrame::NONE, &clock);let b = zoom_state_at(&plain, t / 4.0, None);- assert!((a.scale - b.scale).abs() < 1e-4, "t={t} : {} vs {}", a.scale, b.scale);+ assert!(+ (a.scale - b.scale).abs() < 1e-4,+ "t={t} : {} vs {}",+ a.scale,+ b.scale+ );assert!((a.focus[0] - b.focus[0]).abs() < 1e-4, "t={t}");let a = camera_fullscreen_progress_at(&full_camera(4.0), t, &clock);- let b = camera_fullscreen_progress_at(&full_camera(1.0), t / 4.0, &ScreenClock::default());+ let b =+ camera_fullscreen_progress_at(&full_camera(1.0), t / 4.0, &ScreenClock::default());assert!((a - b).abs() < 1e-4, "Full Camera t={t} : {a} vs {b}");}}@@ -1692,7 +1992,8 @@ mod zoom_focus_tests {for seg in speed_segments_for_window(speeds, 0.0, 20.0, 60.0) {for k in 0..seg.frame_count {let t = (seg.start_sec + k as f64 * seg.speed / 60.0) as f32;- let scale = zoom_state_in(&[r.clone()], t, None, &CameraFrame::NONE, &clock).scale;+ let scale =+ zoom_state_in(&[r.clone()], t, None, &CameraFrame::NONE, &clock).scale;if scale > 1.0 && scale < 2.0 {frames += 1;}@@ -1704,8 +2005,14 @@ mod zoom_focus_tests {};let (plain_frames, plain_step) = walk(&[]);let (sped_frames, sped_step) = walk(&[speed(None, 9.5, 11.0, 8.0)]);- assert!(plain_frames.abs_diff(sped_frames) <= 2, "{plain_frames} vs {sped_frames} frames");- assert!(sped_step <= plain_step + 0.01, "saut de {sped_step} (1× : {plain_step})");+ assert!(+ plain_frames.abs_diff(sped_frames) <= 2,+ "{plain_frames} vs {sped_frames} frames"+ );+ assert!(+ sped_step <= plain_step + 0.01,+ "saut de {sped_step} (1× : {plain_step})"+ );}}@@ -1738,8 +2045,16 @@ mod arrow_tests {// ~25° du fût quand les cardinales ouvrent à 45°, ce qui donnait une pointe étroite,// avalée par le fût dès que le trait épaississait. Corriger la longueur seule ne suffisait// pas — ce test verrouille l'angle, qui est le paramètre réellement visible.- for dir in ["up", "down", "left", "right", "up-right", "up-left", "down-right", "down-left"]- {+ for dir in [+ "up",+ "down",+ "left",+ "right",+ "up-right",+ "up-left",+ "down-right",+ "down-left",+ ] {for barb in 1..=2 {let deg = barb_opening_deg(dir, barb);assert!(@@ -1755,7 +2070,8 @@ mod arrow_tests {// Les barbes diagonales faisaient 15,8 unités contre 21,2 pour les cardinales : une// flèche en diagonale avait une tête ~25 % plus petite que sa voisine horizontale, ce// qui se lisait comme une déformation. Ce test interdit la divergence de revenir.- let barb_len = |seg: [f32; 4]| ((seg[2] - seg[0]).powi(2) + (seg[3] - seg[1]).powi(2)).sqrt();+ let barb_len =+ |seg: [f32; 4]| ((seg[2] - seg[0]).powi(2) + (seg[3] - seg[1]).powi(2)).sqrt();let cardinal = barb_len(arrow_segments_viewbox("up")[1]);for dir in ["up-right", "up-left", "down-right", "down-left"] {for barb in 1..=2 {@@ -1774,11 +2090,19 @@ mod arrow_tests {// dessinent deux flèches différentes.assert_eq!(arrow_segments_viewbox("right"),- [[20.0, 50.0, 80.0, 50.0], [80.0, 50.0, 65.0, 35.0], [80.0, 50.0, 65.0, 65.0]]+ [+ [20.0, 50.0, 80.0, 50.0],+ [80.0, 50.0, 65.0, 35.0],+ [80.0, 50.0, 65.0, 65.0]+ ]);assert_eq!(arrow_segments_viewbox("up"),- [[50.0, 20.0, 50.0, 80.0], [50.0, 20.0, 35.0, 35.0], [50.0, 20.0, 65.0, 35.0]]+ [+ [50.0, 20.0, 50.0, 80.0],+ [50.0, 20.0, 35.0, 35.0],+ [50.0, 20.0, 65.0, 35.0]+ ]);}@@ -1786,7 +2110,10 @@ mod arrow_tests {fn an_unknown_direction_falls_back_to_right() {// Même défaut que le schéma côté app, pour qu'une donnée abîmée dessine quelque chose// de sensé plutôt que rien.- assert_eq!(arrow_segments_viewbox("sideways"), arrow_segments_viewbox("right"));+ assert_eq!(+ arrow_segments_viewbox("sideways"),+ arrow_segments_viewbox("right")+ );}#[test]@@ -1836,7 +2163,10 @@ mod tilt_tests {{let (x, y) = quad.point_px(fx, fy);let (ex, ey) = quad.corners[i];- assert!((x - ex).abs() < 1e-3 && (y - ey).abs() < 1e-3, "coin {i}: {x},{y} != {ex},{ey}");+ assert!(+ (x - ex).abs() < 1e-3 && (y - ey).abs() < 1e-3,+ "coin {i}: {x},{y} != {ex},{ey}"+ );}}@@ -1865,7 +2195,10 @@ mod tilt_tests {let (ux, uy) = ((fx - 0.5) * w, (fy - 0.5) * h);worst = worst.max((x - ux).hypot(y - uy));}- assert!(worst > 20.0, "ecart max au rect droit trop faible: {worst}px");+ assert!(+ worst > 20.0,+ "ecart max au rect droit trop faible: {worst}px"+ );}/// Le contrat du containment : après projection, aucun coin ne sort du rect d'origine.@@ -1948,13 +2281,18 @@ mod tilt_tests {let quad = rotated_quad_corners_px(w, h, rot, [0.0; 3]);let mb = quad.depth_mb([w, h], [0.5, 0.5], false);let perspective = w.min(h) * PERSPECTIVE_FACTOR;- for (i, (s, t)) in [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)].into_iter().enumerate()+ for (i, (s, t)) in [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]+ .into_iter()+ .enumerate(){let (x0, y0) = ((s - 0.5) * w * quad.scale, (t - 0.5) * h * quad.scale);// Même repère que les coins : projeter ce point redonne le coin rendu.let (px, py) = project_corner(x0, y0, rot, perspective).unwrap();let (cx, cy) = quad.corners[i];- assert!((px - cx).abs() < 1e-2 && (py - cy).abs() < 1e-2, "{name} coin {i}");+ assert!(+ (px - cx).abs() < 1e-2 && (py - cy).abs() < 1e-2,+ "{name} coin {i}"+ );}for i in 0..=8 {for j in 0..=8 {@@ -1990,7 +2328,10 @@ mod tilt_tests {quad.corners[i].0.hypot(quad.corners[i].1) / rx.hypot(ry)};let (m_tr, m_bl) = (magnification(1, 1.0, 0.0), magnification(3, 0.0, 1.0));- assert!(m_tr > m_bl * 1.2, "TR x{m_tr} devrait être nettement plus grossi que BL x{m_bl}");+ assert!(+ m_tr > m_bl * 1.2,+ "TR x{m_tr} devrait être nettement plus grossi que BL x{m_bl}"+ );}/// Le focus au centre du plan est à la profondeur du centre (0), et `k` reste nul réglage@@ -2048,7 +2389,10 @@ mod tilt_tests {// d'un quad incliné ne peuvent pas rester alignés deux à deux comme un rectangle droit.let corners = rotated_quad_corners_px(1920.0, 1080.0, preset("left"), [0.0; 3]).corners;let top_edge_slope = (corners[1].1 - corners[0].1).abs();- assert!(top_edge_slope > 1.0, "arête supérieure horizontale : le tilt a disparu");+ assert!(+ top_edge_slope > 1.0,+ "arête supérieure horizontale : le tilt a disparu"+ );}fn preset(name: &str) -> [f32; 3] {@@ -2059,7 +2403,10 @@ mod tilt_tests {pub(super) fn min_edge_angle(c: &[(f32, f32); 4]) -> f32 {let h = |p: (f32, f32), q: (f32, f32)| (q.1 - p.1).atan2(q.0 - p.0).to_degrees().abs();let v = |p: (f32, f32), q: (f32, f32)| (q.0 - p.0).atan2(q.1 - p.1).to_degrees().abs();- h(c[0], c[1]).min(h(c[3], c[2])).min(v(c[0], c[3])).min(v(c[1], c[2]))+ h(c[0], c[1])+ .min(h(c[3], c[2]))+ .min(v(c[0], c[3]))+ .min(v(c[1], c[2]))}/// Débordement relatif du quad hors du rect d'origine (> 0 = déborde).@@ -2075,7 +2422,11 @@ mod tilt_tests {let b = DYNAMIC_TILT_BUDGET;(-n..=n).flat_map(move |i| {(-n..=n).map(move |j| {- [b[0] * g * i as f32 / n as f32, b[1] * g * j as f32 / n as f32, 0.0]+ [+ b[0] * g * i as f32 / n as f32,+ b[1] * g * j as f32 / n as f32,+ 0.0,+ ]})})}@@ -2182,7 +2533,10 @@ mod tilt_tests {let state = zoom_state_at(®ions, t, None);let base = state.rotation;// Jamais les deux modèles à la fois.- assert!(state.camera == 0.0 || is_identity_rotation(base), "{a:?}→{b:?} t {t}");+ assert!(+ state.camera == 0.0 || is_identity_rotation(base),+ "{a:?}→{b:?} t {t}"+ );let gate = smoothstep(PARALLAX_GATE_START, 1.0, state.tilt);for (w, h) in [(1920.0f32, 1080.0f32), (1080.0, 1920.0), (800.0, 800.0)] {let still = rotated_quad_corners_px(w, h, base, [0.0; 3]).corners;@@ -2214,7 +2568,11 @@ mod tilt_tests {// entre deux caméras réelles, la caméra aussi.if a.is_some() && a == b {let mid = zoom_state_at(®ions, 4.5, None);- let open = if a == Some("follow-cursor") { mid.camera } else { mid.tilt };+ let open = if a == Some("follow-cursor") {+ mid.camera+ } else {+ mid.tilt+ };assert_eq!(open, 1.0, "{a:?}");}}@@ -2272,7 +2630,10 @@ mod tilt_tests {"force {strength}");}- assert_ne!(dynamic_tilt(1.0, Some(&track), FULL_CUT, 0.95, [0.0; 3]), [0.0; 3]);+ assert_ne!(+ dynamic_tilt(1.0, Some(&track), FULL_CUT, 0.95, [0.0; 3]),+ [0.0; 3]+ );}/// Le geste penche le plan dans son sens, puis le plan revient à la pose du préset au repos.@@ -2287,7 +2648,9 @@ mod tilt_tests {assert!(rest[1].abs() < 0.05, "au repos : {rest:?}");// Vers le bas → le bord bas recule (−X).let down = CursorTrack::new(- (0..=60).map(|i| (i as f32 / 30.0, 0.5, 0.1 + 0.4 * i as f32 / 30.0)).collect(),+ (0..=60)+ .map(|i| (i as f32 / 30.0, 0.5, 0.1 + 0.4 * i as f32 / 30.0))+ .collect(),vec![],vec![],);@@ -2303,7 +2666,10 @@ mod tilt_tests {let track = swipe(speed, 9.0);for cut in [FULL_CUT, [0.4, 0.4, 0.45, 0.45]] {let d = dynamic_tilt(1.0, Some(&track), cut, 1.0, [0.0; 3]);- assert!(d[0].abs() <= b[0] && d[1].abs() <= b[1] && d[2] == 0.0, "{speed} {d:?}");+ assert!(+ d[0].abs() <= b[0] && d[1].abs() <= b[1] && d[2] == 0.0,+ "{speed} {d:?}"+ );}}let fast = dynamic_tilt(1.0, Some(&swipe(1000.0, 9.0)), FULL_CUT, 1.0, [0.0; 3]);@@ -2341,8 +2707,14 @@ mod tilt_tests {(hi, hi_ms) = (v, ms);}}- assert!((lo + 1.0).abs() < 1e-3 && (lo_ms - 49.5).abs() < 0.3, "creux {lo} à {lo_ms} ms");- assert!((hi - 0.164).abs() < 1e-3 && (hi_ms - 165.3).abs() < 0.5, "rebond {hi} à {hi_ms} ms");+ assert!(+ (lo + 1.0).abs() < 1e-3 && (lo_ms - 49.5).abs() < 0.3,+ "creux {lo} à {lo_ms} ms"+ );+ assert!(+ (hi - 0.164).abs() < 1e-3 && (hi_ms - 165.3).abs() < 0.5,+ "rebond {hi} à {hi_ms} ms"+ );assert_eq!(tap(1.0), 0.0);assert_eq!(tap(-1e-4), 0.0);assert_eq!(tap(0.0), 0.0);@@ -2351,13 +2723,21 @@ mod tilt_tests {// Pas de cassure de pente (celle de `bounce` à 98,8 ms) : dérivée seconde bornée partout.let d2 = |e: f32| (tap(e + 1e-3) - 2.0 * tap(e) + tap(e - 1e-3)) / 1e-6;for i in 2..998 {- assert!(d2(i as f32 / 1000.0).abs() < 60.0, "cassure à e = {}", i as f32 / 1000.0);+ assert!(+ d2(i as f32 / 1000.0).abs() < 60.0,+ "cassure à e = {}",+ i as f32 / 1000.0+ );}}/// Une piste immobile au point `(x, y)`, avec des clics.fn still(x: f32, y: f32, clicks: Vec<f32>) -> CursorTrack {- CursorTrack::new((0..=90).map(|i| (i as f32 / 30.0, x, y)).collect(), clicks, vec![])+ CursorTrack::new(+ (0..=90).map(|i| (i as f32 / 30.0, x, y)).collect(),+ clicks,+ vec![],+ )}/// La coupe entière, sans restriction : le point de la piste EST le point du plan.@@ -2372,22 +2752,43 @@ mod tilt_tests {fn the_clicked_side_recedes() {let t = 1.0 + 49.5 / 1000.0;let right = click_impact(t, &still(1.0, 0.5, vec![1.0]), WHOLE, full_aim);- assert!((right[1] - CLICK_IMPACT_DEG).abs() < 1e-2 && right[0].abs() < 1e-6, "{right:?}");+ assert!(+ (right[1] - CLICK_IMPACT_DEG).abs() < 1e-2 && right[0].abs() < 1e-6,+ "{right:?}"+ );let bottom = click_impact(t, &still(0.5, 1.0, vec![1.0]), WHOLE, full_aim);- assert!((bottom[0] + CLICK_IMPACT_DEG).abs() < 1e-2 && bottom[1].abs() < 1e-6, "{bottom:?}");+ assert!(+ (bottom[0] + CLICK_IMPACT_DEG).abs() < 1e-2 && bottom[1].abs() < 1e-6,+ "{bottom:?}"+ );let z = |x: f32, y: f32, rot: [f32; 3]| rotate_corner(x, y, rot).2;for name in ["left", "right"] {let base = preset(name);let with = |d: [f32; 3]| [base[0] + d[0], base[1] + d[1], base[2] + d[2]];// Milieu du bord droit / du bord bas, et le bord opposé qui avance.- assert!(z(960.0, 0.0, with(right)) < z(960.0, 0.0, base), "{name} droite");- assert!(z(-960.0, 0.0, with(right)) > z(-960.0, 0.0, base), "{name} gauche");- assert!(z(0.0, 540.0, with(bottom)) < z(0.0, 540.0, base), "{name} bas");- assert!(z(0.0, -540.0, with(bottom)) > z(0.0, -540.0, base), "{name} haut");+ assert!(+ z(960.0, 0.0, with(right)) < z(960.0, 0.0, base),+ "{name} droite"+ );+ assert!(+ z(-960.0, 0.0, with(right)) > z(-960.0, 0.0, base),+ "{name} gauche"+ );+ assert!(+ z(0.0, 540.0, with(bottom)) < z(0.0, 540.0, base),+ "{name} bas"+ );+ assert!(+ z(0.0, -540.0, with(bottom)) > z(0.0, -540.0, base),+ "{name} haut"+ );}// Au centre : pas d'axe, rien ne bouge.- assert_eq!(click_impact(t, &still(0.5, 0.5, vec![1.0]), WHOLE, full_aim), [0.0; 3]);+ assert_eq!(+ click_impact(t, &still(0.5, 0.5, vec![1.0]), WHOLE, full_aim),+ [0.0; 3]+ );}/// Double clic : la somme est bornée — à 33 ms d'écart elle atteindrait 1,81.@@ -2397,23 +2798,53 @@ mod tilt_tests {let mut peak = 0.0f32;for i in 0..400 {let d = click_impact(1.0 + i as f32 / 1000.0, &track, WHOLE, full_aim);- assert!(d[0].abs() <= CLICK_IMPACT_DEG && d[1].abs() <= CLICK_IMPACT_DEG, "{d:?}");+ assert!(+ d[0].abs() <= CLICK_IMPACT_DEG && d[1].abs() <= CLICK_IMPACT_DEG,+ "{d:?}"+ );peak = peak.max(d[1]);}- assert_eq!(peak, CLICK_IMPACT_DEG, "la somme brute dépasse 1 et se fait borner");+ assert_eq!(+ peak, CLICK_IMPACT_DEG,+ "la somme brute dépasse 1 et se fait borner"+ );}/// Rien hors de la fenêtre du clic, du clip actif ou de la coupe visible.#[test]fn clicks_outside_the_window_the_clip_or_the_crop_do_nothing() {let track = still(1.0, 0.5, vec![1.0]);- assert_eq!(click_impact(0.99, &track, WHOLE, full_aim), [0.0; 3], "avant le clic");- assert_eq!(click_impact(1.26, &track, WHOLE, full_aim), [0.0; 3], "après 260 ms");+ assert_eq!(+ click_impact(0.99, &track, WHOLE, full_aim),+ [0.0; 3],+ "avant le clic"+ );+ assert_eq!(+ click_impact(1.26, &track, WHOLE, full_aim),+ [0.0; 3],+ "après 260 ms"+ );let t = 1.05;- assert_eq!(click_impact(t, &track, [1.01, 9.0], full_aim), [0.0; 3], "clic coupé avant");- assert_eq!(click_impact(t, &track, [0.0, 1.0], full_aim), [0.0; 3], "fin exclusive");- assert_ne!(click_impact(t, &track, [1.0, 9.0], full_aim), [0.0; 3], "début inclus");- assert_eq!(click_impact(t, &track, WHOLE, |_| None), [0.0; 3], "hors coupe");+ assert_eq!(+ click_impact(t, &track, [1.01, 9.0], full_aim),+ [0.0; 3],+ "clic coupé avant"+ );+ assert_eq!(+ click_impact(t, &track, [0.0, 1.0], full_aim),+ [0.0; 3],+ "fin exclusive"+ );+ assert_ne!(+ click_impact(t, &track, [1.0, 9.0], full_aim),+ [0.0; 3],+ "début inclus"+ );+ assert_eq!(+ click_impact(t, &track, WHOLE, |_| None),+ [0.0; 3],+ "hors coupe"+ );assert_eq!(dynamic_tilt(t, None, FULL_CUT, 1.0, [0.0; 3]), [0.0; 3]);}@@ -2424,7 +2855,15 @@ mod tilt_tests {(0..=90).map(|i| {let t = i as f32 / 30.0;- (t, if t <= 1.0 { 1.0 } else { (1.0 - 3.0 * (t - 1.0)).max(0.0) }, 0.5)+ (+ t,+ if t <= 1.0 {+ 1.0+ } else {+ (1.0 - 3.0 * (t - 1.0)).max(0.0)+ },+ 0.5,+ )}).collect(),vec![1.0],@@ -2448,7 +2887,10 @@ mod tilt_tests {let impact = [-CLICK_IMPACT_DEG, CLICK_IMPACT_DEG, 0.0];for k in 0..=85 {let strength = k as f32 / 100.0;- assert_eq!(dynamic_tilt(1.0, None, FULL_CUT, strength, impact), [0.0; 3]);+ assert_eq!(+ dynamic_tilt(1.0, None, FULL_CUT, strength, impact),+ [0.0; 3]+ );}assert_eq!(dynamic_tilt(1.0, None, FULL_CUT, 1.0, impact), impact);let b = DYNAMIC_TILT_BUDGET;@@ -2459,7 +2901,10 @@ mod tilt_tests {assert!(d[1] <= b[1] && d[1] > b[1] - 1e-3, "{d:?}");let d = dynamic_tilt(1.0, Some(&fast), FULL_CUT, 0.95, impact);let gate = smoothstep(PARALLAX_GATE_START, 1.0, 0.95);- assert!(d[1] <= b[1] * gate + 1e-5 && d[0].abs() <= b[0] * gate + 1e-5, "{d:?}");+ assert!(+ d[1] <= b[1] * gate + 1e-5 && d[0].abs() <= b[0] * gate + 1e-5,+ "{d:?}"+ );}/// Échelle gelée pendant l'impact : seuls les coins bougent, et assez pour se voir.@@ -2500,7 +2945,11 @@ mod tilt_tests {};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");+ 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.@@ -2548,7 +2997,10 @@ mod tilt_tests {let e = sub(c10, c00);let f = sub(c01, c00);let g = (c00.0 - c10.0 - c01.0 + c11.0, c00.1 - c10.1 - c01.1 + c11.1);- (c00.0 + e.0 * s + f.0 * t + g.0 * s * t, c00.1 + e.1 * s + f.1 * t + g.1 * s * t)+ (+ c00.0 + e.0 * s + f.0 * t + g.0 * s * t,+ c00.1 + e.1 * s + f.1 * t + g.1 * s * t,+ )}/// `None` = le shader rend ce pixel TRANSPARENT (donc un trou dans l'écran incliné).@@ -2646,7 +3098,12 @@ mod exporter_frame_totals {use crate::scene::SceneSpeedRegion;fn region(start_sec: f64, end_sec: f64, speed: f64) -> SceneSpeedRegion {- SceneSpeedRegion { clip_index: None, start_sec, end_sec, speed }+ SceneSpeedRegion {+ clip_index: None,+ start_sec,+ end_sec,+ speed,+ }}fn frames(start_sec: f64, end_sec: f64, regions: &[SceneSpeedRegion], fps: f64) -> u64 {@@ -2674,7 +3131,11 @@ mod exporter_frame_totals {240,"1,25× : 80 % de 300, exactement le symptôme");- assert_eq!(frames(0.0, 10.0, &[region(0.0, 10.0, 0.5)], FPS), 600, "0,5×");+ assert_eq!(+ frames(0.0, 10.0, &[region(0.0, 10.0, 0.5)], FPS),+ 600,+ "0,5×"+ );assert_eq!(frames(0.0, 10.0, &[region(2.0, 4.0, 2.0)], FPS),60 + 30 + 180,@@ -2686,7 +3147,12 @@ mod exporter_frame_totals {"région débordant la fenêtre gardée");assert_eq!(- frames(0.0, 10.0, &[region(2.0, 6.0, 2.0), region(4.0, 8.0, 4.0)], FPS),+ frames(+ 0.0,+ 10.0,+ &[region(2.0, 6.0, 2.0), region(4.0, 8.0, 4.0)],+ FPS+ ),60 + 60 + 15 + 60,"recouvrement : la première région garde la portion déjà couverte");@@ -2828,7 +3294,11 @@ mod follow_camera_tests {}fn whole(track: &CursorTrack) -> CameraFrame<'_> {- CameraFrame { track: Some(track), crop: [0.0, 0.0, 1.0, 1.0], window: [0.0, 100.0] }+ CameraFrame {+ track: Some(track),+ crop: [0.0, 0.0, 1.0, 1.0],+ window: [0.0, 100.0],+ }}/// Sous `follow-cursor`, l'écran n'est pas incliné et ne glisse pas (focus au centre, quel que@@ -2841,23 +3311,47 @@ mod follow_camera_tests {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));+ assert_eq!(+ (full.rotation, full.tilt, full.click_impact, full.camera),+ ([0.0; 3], 0.0, 1.0, 1.0)+ );assert_eq!((full.scale, full.focus), (2.0, [0.5, 0.5]));- assert!(full.aim[0] > 0.7 && (full.aim[1] - 0.5).abs() < 1e-3, "{:?}", full.aim);- assert!((full.orbit[0] - 0.85).abs() < 1e-3 && (full.orbit[1] - 0.5).abs() < 1e-3, "{:?}", full.orbit);+ assert!(+ full.aim[0] > 0.7 && (full.aim[1] - 0.5).abs() < 1e-3,+ "{:?}",+ full.aim+ );+ assert!(+ (full.orbit[0] - 0.85).abs() < 1e-3 && (full.orbit[1] - 0.5).abs() < 1e-3,+ "{:?}",+ full.orbit+ );let easing = zoom_state_in(&r, 1.5, Some(&tr), &f, &ScreenClock::default());- assert!(easing.camera > 0.0 && easing.camera < 1.0, "{}", easing.camera);+ assert!(+ easing.camera > 0.0 && easing.camera < 1.0,+ "{}",+ easing.camera+ );let raw = follow_at(&r[0], 1.5, &f);- assert_eq!((easing.aim, easing.orbit), (weighted(raw.aim, easing.camera), weighted(raw.orbit, easing.camera)));+ assert_eq!(+ (easing.aim, easing.orbit),+ (+ weighted(raw.aim, easing.camera),+ weighted(raw.orbit, easing.camera)+ )+ );assert_eq!(easing.focus, [0.5, 0.5]);let out = zoom_state_in(&r, 0.0, Some(&tr), &f, &ScreenClock::default());- assert_eq!((out.scale, out.rotation, out.camera, out.aim, out.orbit), (1.0, [0.0; 3], 0.0, [0.5; 2], [0.5; 2]));+ assert_eq!(+ (out.scale, out.rotation, out.camera, out.aim, out.orbit),+ (1.0, [0.0; 3], 0.0, [0.5; 2], [0.5; 2])+ );// Sans piste, la caméra vise le centre, au repos.let blind = zoom_state_at(&r, 5.0, None);assert_eq!((blind.aim, blind.orbit), ([0.5, 0.5], [0.5, 0.5]));// Un angle fixe garde exactement son état.- let iso = zoom_state_in(&[region("left", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());- assert_eq!((iso.rotation, iso.camera, iso.click_impact), ([-23.0, -25.0, 0.0], 0.0, 1.0));+ 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), ([-23.0, -25.0, 0.0], 0.0, 1.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));}@@ -2869,8 +3363,20 @@ mod follow_camera_tests {let mut auto = region("follow-cursor", 2.0, 8.0);auto.focus_mode = Some("auto".into());let manual = region("follow-cursor", 2.0, 8.0);- let a = zoom_state_in(&[auto], 5.0, Some(&tr), &whole(&tr), &ScreenClock::default());- let m = zoom_state_in(&[manual], 5.0, Some(&tr), &whole(&tr), &ScreenClock::default());+ let a = zoom_state_in(+ &[auto],+ 5.0,+ Some(&tr),+ &whole(&tr),+ &ScreenClock::default(),+ );+ let m = zoom_state_in(+ &[manual],+ 5.0,+ Some(&tr),+ &whole(&tr),+ &ScreenClock::default(),+ );assert_eq!((a.aim, a.focus), (m.aim, m.focus));assert!(a.aim[0] > 0.7 && a.aim[1] < 0.35, "{:?}", a.aim);}@@ -2884,7 +3390,10 @@ mod follow_camera_tests {for regions in [[region("left", 1.0, 4.0), region("follow-cursor", 4.5, 8.0)],[region("follow-cursor", 1.0, 4.0), region("right", 4.5, 8.0)],- [region("follow-cursor", 1.0, 4.0), region("follow-cursor", 4.5, 8.0)],+ [+ region("follow-cursor", 1.0, 4.0),+ region("follow-cursor", 4.5, 8.0),+ ],] {let both = regions[0].rotation == regions[1].rotation;let mut last: Option<ZoomState> = None;@@ -2892,14 +3401,22 @@ mod follow_camera_tests {// La transition chaînée couvre [4, 5] s, le palier la suit jusqu'à 4,5 s.let t = 3.9 + k as f32 * 1.3 / 400.0;let s = zoom_state_in(®ions, t, Some(&tr), &f, &ScreenClock::default());- assert!(s.camera == 0.0 || is_identity_rotation(s.rotation), "t {t} : {s:?}", s = (s.camera, s.rotation));+ assert!(+ s.camera == 0.0 || is_identity_rotation(s.rotation),+ "t {t} : {s:?}",+ s = (s.camera, s.rotation)+ );if both {assert_eq!(s.camera, 1.0, "t {t}");}if let Some(p) = &last {let jump = (s.camera - p.camera).abs()- + (0..3).map(|i| (s.rotation[i] - p.rotation[i]).abs() / 20.0).sum::<f32>()- + (0..2).map(|i| (s.aim[i] - p.aim[i]).abs() + (s.orbit[i] - p.orbit[i]).abs()).sum::<f32>();+ + (0..3)+ .map(|i| (s.rotation[i] - p.rotation[i]).abs() / 20.0)+ .sum::<f32>()+ + (0..2)+ .map(|i| (s.aim[i] - p.aim[i]).abs() + (s.orbit[i] - p.orbit[i]).abs())+ .sum::<f32>();assert!(jump < 0.05, "saut à t {t} : {jump}");}last = Some(s);@@ -2914,7 +3431,13 @@ mod follow_camera_tests {let f = whole(&tr);let r = [region("follow-cursor", 2.0, 8.0)];let at = |i: usize| {- let s = zoom_state_in(&r, 1.0 + i as f32 / 30.0, Some(&tr), &f, &ScreenClock::default());+ let s = zoom_state_in(+ &r,+ 1.0 + i as f32 / 30.0,+ Some(&tr),+ &f,+ &ScreenClock::default(),+ );(s.camera, s.aim, s.orbit, s.scale)};let forward: Vec<_> = (0..240).map(at).collect();