From 6a20551a8dc67bc187af689012334e53eeff5fbd Mon Sep 17 00:00:00 2001 From: "alexey.lovchikov" Date: Sun, 22 Nov 2026 15:55:49 +0500 Subject: [PATCH 1/2] fix(cursor): restart the cursor spring at every clip window The cursor spring ran over the whole recording, including footage a trim or a clip boundary removed. At the cut the drawn cursor was wherever the hidden path had dragged the spring, so it teleported late. The spring now restarts at the source start of every clip window on the file, the same way it already restarts when the cursor reappears, in preview and export. Co-Authored-By: Claude Opus 5.5 --- crates/compositor/src/cursor.rs | 51 +++++++++++++++++++++++++- crates/compositor/src/live.rs | 23 ++++++++++-- crates/compositor/src/scene.rs | 11 ++++++ crates/compositor/src/timeline_walk.rs | 7 +++- 4 files changed, 86 insertions(+), 6 deletions(-) diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs index cec1353112..b33cfcd62d 100644 --- a/crates/compositor/src/cursor.rs +++ b/crates/compositor/src/cursor.rs @@ -513,6 +513,15 @@ impl CursorTrack { /// du slider (0 = passthrough, retourne un clone). Les clics restent sur leurs instants /// bruts (le bounce est temporel, pas positionnel — ne doit pas suivre le lissage). pub fn smoothed(&self, factor: f32) -> CursorTrack { + self.smoothed_with_breaks(factor, &[]) + } + + /// `smoothed(factor)`, with the spring also restarted at each of `breaks` (source seconds), + /// as it already restarts when the cursor reappears. The callers pass the start of every clip + /// window on this file (`Scene::cursor_breaks_for`): without them the spring ran across the + /// footage a trim or a clip boundary removed, and the drawn cursor teleported at the cut to + /// wherever that hidden path had dragged it. + pub fn smoothed_with_breaks(&self, factor: f32, breaks: &[f32]) -> CursorTrack { if self.samples.len() < 2 || factor <= 0.0 { return CursorTrack::new_with_visibility( self.samples.clone(), @@ -542,14 +551,22 @@ impl CursorTrack { } let (stiffness, damping, mass) = cursor_spring_config(factor); // Une phase masquée coupe le ressort. Au retour, le curseur repart du premier point - // réellement visible au lieu de traverser la trajectoire cachée avec du retard. + // réellement visible au lieu de traverser la trajectoire cachée avec du retard. A break + // (a clip window's start) cuts it the same way. + let mut sorted_breaks: Vec = breaks.iter().copied().filter(|b| b.is_finite()).collect(); + sorted_breaks.sort_by(|a, b| a.partial_cmp(b).unwrap()); + let segment_of = |t: f32| sorted_breaks.partition_point(|&b| b <= t); let mut xs = Vec::with_capacity(n); let mut ys = Vec::with_capacity(n); let mut run_start = 0; while run_start < n { let visible = self.visible_at(times[run_start]); + let segment = segment_of(times[run_start]); let mut run_end = run_start + 1; - while run_end < n && self.visible_at(times[run_end]) == visible { + while run_end < n + && self.visible_at(times[run_end]) == visible + && segment_of(times[run_end]) == segment + { run_end += 1; } xs.extend(spring_smooth( @@ -1215,3 +1232,33 @@ mod tests { assert_eq!(track.opacity_at(5.9, true), 0.0); } } + +#[cfg(test)] +mod break_tests { + use super::*; + + #[test] + fn smoothed_without_breaks_is_unchanged() { + let samples: Vec<_> = (0..=60).map(|i| (i as f32 / 30.0, 0.1 + 0.01 * i as f32, 0.5)).collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + for t in [0.0, 0.7, 1.3, 2.0] { + assert_eq!(raw.smoothed_with_breaks(0.4, &[]).at(t), raw.smoothed(0.4).at(t)); + } + } + + #[test] + fn a_break_restarts_the_spring_so_a_cut_does_not_teleport_late() { + // Still at x = 0.1 until 2 s, then at x = 0.9: what a cut to later footage looks like. + let samples: Vec<_> = (0..=120) + .map(|i| { + let t = i as f32 / 30.0; + (t, if t < 2.0 { 0.1 } else { 0.9 }, 0.5) + }) + .collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + let lagging = raw.smoothed(0.5).at(2.05).unwrap().0; + let restarted = raw.smoothed_with_breaks(0.5, &[2.0]).at(2.05).unwrap().0; + assert!(lagging < 0.8, "without a break the spring still trails: {lagging}"); + assert!((restarted - 0.9).abs() < 1e-3, "after a break it starts on the pointer: {restarted}"); + } +} diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs index 52a95f905f..e6410a815a 100644 --- a/crates/compositor/src/live.rs +++ b/crates/compositor/src/live.rs @@ -903,6 +903,7 @@ fn reload_cursor_if_changed( screen_path: &str, turned: bool, smoothing: f32, + breaks: &[f32], ) -> bool { let key = cursor_key(screen_path, turned); if key == *loaded_cursor_path { @@ -929,12 +930,17 @@ fn reload_cursor_if_changed( // curseur (`Compositor::resized`), et le relisser parcourt tout // l'enregistrement à chaque bascule d'un scrub. match raw_cursor { - Some(track) => comp.set_cursor(track.smoothed(smoothing)), + Some(track) => comp.set_cursor(track.smoothed_with_breaks(smoothing, breaks)), None => comp.clear_cursor(), } true } +/// Where the spring of `screen_path`'s cursor track restarts (`Scene::cursor_breaks_for`). +fn cursor_breaks(scene: Option<&Scene>, screen_path: &str) -> Vec { + scene.map(|s| s.cursor_breaks_for(screen_path)).unwrap_or_default() +} + fn scene_for_clip(scene: &Scene, clip_index: usize) -> Scene { match scene.clips.get(clip_index) { Some(clip) => scene.for_clip_window( @@ -1699,6 +1705,8 @@ unsafe fn render_thread( let mut last_preview_size: (u32, u32) = (0, 0); let mut last_ip: Option = None; let mut last_smoothing: f32 = -1.0; // force la 1re application (0.0 est une valeur valide) + // The breaks the current track was smoothed with (`cursor_breaks`). + let mut last_breaks: Vec = Vec::new(); // Fenêtre de stabilisation après un changement EN PAUSE. Un seul recompose ne suffit pas // quand l'effet demandé est asynchrone : la segmentation webcam (détourage / flou / fond // personnalisé) démarre son worker au 1er compose, ne SOUMET la frame qu'au 2e et ne @@ -1812,6 +1820,7 @@ unsafe fn render_thread( // construction identique. Mesuré : 66 bascules sur un scrub de deux clips, // donc 66 relectures du même fichier. // The key also carries the clip's turn: the same file turned is another track. + let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); if reload_cursor_if_changed( &comp, &mut raw_cursor, @@ -1819,8 +1828,10 @@ unsafe fn render_thread( &active_screen_path, turned, ip.cursor_smoothing, + &breaks, ) { last_smoothing = ip.cursor_smoothing; + last_breaks = breaks; } clip_changed = true; } @@ -1858,10 +1869,13 @@ unsafe fn render_thread( }); // Lissage ressort-amortisseur : re-génère la piste (240 Hz) uniquement quand la valeur // change (pas à chaque frame — le resample+ressort parcourt tout l'enregistrement). + // The clip breaks reshape it the same way, when the scene changes them. if let Some(raw) = &raw_cursor { - if ip.cursor_smoothing != last_smoothing { - comp.set_cursor(raw.smoothed(ip.cursor_smoothing)); + let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); + if ip.cursor_smoothing != last_smoothing || breaks != last_breaks { + comp.set_cursor(raw.smoothed_with_breaks(ip.cursor_smoothing, &breaks)); last_smoothing = ip.cursor_smoothing; + last_breaks = breaks; } } // un changement de param doit se voir même en pause (édition live des sliders) : @@ -1894,6 +1908,7 @@ unsafe fn render_thread( // here, mirrored the new way. let turned = scene.as_ref().is_some_and(Scene::screen_turned); comp.set_scene(scene); + let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); if reload_cursor_if_changed( &comp, &mut raw_cursor, @@ -1901,8 +1916,10 @@ unsafe fn render_thread( &active_screen_path, turned, ip.cursor_smoothing, + &breaks, ) { last_smoothing = ip.cursor_smoothing; + last_breaks = breaks; } } // Le temps programme dépend du clip actif ET de la scène entière (durées des clips diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs index b4a5fb11d9..d27b20150c 100644 --- a/crates/compositor/src/scene.rs +++ b/crates/compositor/src/scene.rs @@ -973,6 +973,17 @@ pub struct Scene { } impl Scene { + /// Where the cursor spring of `screen_path`'s track restarts: the source start of every clip + /// window on that file (`CursorTrack::smoothed_with_breaks`). A trim splits a clip into kept + /// segments, each a clip here, so the instant after a cut is a window start too. + pub fn cursor_breaks_for(&self, screen_path: &str) -> Vec { + self.clips + .iter() + .filter(|clip| clip.screen_path == screen_path) + .map(|clip| clip.source_start_sec as f32) + .collect() + } + pub fn layout_at(&self, t: f32) -> Option> { self.layout_regions.iter().find(|r| r.clip_index == self.active_clip_index && t >= r.start_sec && t < r.end_sec).map(|r| r.sample(t)) diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs index ac05f17a14..090f10c381 100644 --- a/crates/compositor/src/timeline_walk.rs +++ b/crates/compositor/src/timeline_walk.rs @@ -512,7 +512,12 @@ unsafe fn walk_timeline( let path = format!("{}.cursor.json", clip.screen); if let Ok(raw) = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) { let raw = if turned { raw.turned() } else { raw }; - cursor_tracks.insert(key.clone(), raw.smoothed(cursor_smoothing)); + // The spring restarts at every clip window on this file, as in preview. + let breaks = scene + .as_ref() + .map(|s| s.cursor_breaks_for(&clip.screen)) + .unwrap_or_default(); + cursor_tracks.insert(key.clone(), raw.smoothed_with_breaks(cursor_smoothing, &breaks)); } // absente/illisible → pas d'entrée : ce clip s'exporte sans curseur (visible, // pas masqué en un curseur fantôme d'un autre clip). From 975a248d3e927a3ba8fa830c384d8a2c4eb97590 Mon Sep 17 00:00:00 2001 From: "alexey.lovchikov" Date: Sun, 22 Nov 2026 16:20:30 +0500 Subject: [PATCH 2/2] fix(cursor): restart per clip window, exactly on its start Review follow-ups: - The restart is the playing clip's own source start only. Every clip start on the file used to restart one shared track, so a second clip over the same footage reset the cursor inside the first. - No restart when the clip before it is the same file ending where this one starts: the source runs on, and a restart would itself be a jump. - The break is a sample of its own, so a clip that starts between two 240 Hz grid samples no longer shows a first frame interpolated from the run before it. - Clips are addressed by index, not by comparing paths. Export reads the raw telemetry once per file and keys the smoothed track by the break. Co-Authored-By: Claude Opus 5.5 --- crates/compositor/src/cursor.rs | 49 ++++++++++++------ crates/compositor/src/live.rs | 14 +++--- crates/compositor/src/scene.rs | 70 ++++++++++++++++++++++---- crates/compositor/src/timeline_walk.rs | 31 ++++++++---- 4 files changed, 125 insertions(+), 39 deletions(-) diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs index b33cfcd62d..6e93bf65be 100644 --- a/crates/compositor/src/cursor.rs +++ b/crates/compositor/src/cursor.rs @@ -517,8 +517,8 @@ impl CursorTrack { } /// `smoothed(factor)`, with the spring also restarted at each of `breaks` (source seconds), - /// as it already restarts when the cursor reappears. The callers pass the start of every clip - /// window on this file (`Scene::cursor_breaks_for`): without them the spring ran across the + /// as it already restarts when the cursor reappears. The callers pass the start of the clip + /// window being played (`Scene::cursor_break_for_clip`): without it the spring ran across the /// footage a trim or a clip boundary removed, and the drawn cursor teleported at the cut to /// wherever that hidden path had dragged it. pub fn smoothed_with_breaks(&self, factor: f32, breaks: &[f32]) -> CursorTrack { @@ -534,18 +534,24 @@ impl CursorTrack { let start = self.samples[0].0; let end = self.samples[self.samples.len() - 1].0; let step_count = (((end - start) / STEP_S).round() as usize).max(1); - let n = step_count + 1; - let mut times = Vec::with_capacity(n); + let mut sorted_breaks: Vec = breaks.iter().copied().filter(|b| b.is_finite()).collect(); + sorted_breaks.sort_by(|a, b| a.partial_cmp(b).unwrap()); + let mut times: Vec = (0..=step_count) + .map(|i| if i == step_count { end } else { start + i as f32 * STEP_S }) + .collect(); + // Each break is a sample of its own, the first of its run: a clip rarely starts on the + // 240 Hz grid, and restarting at the next grid sample instead left the clip's first frame + // interpolating from the run before, still trailing. The one step this shortens is + // integrated as a whole one; the run starts at rest on its target, so nothing visible + // changes. + times.extend(sorted_breaks.iter().copied().filter(|&b| b > start && b < end)); + times.sort_by(|a, b| a.partial_cmp(b).unwrap()); + times.dedup_by(|later, earlier| (*later - *earlier).abs() < 1e-6); + let n = times.len(); 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 - }; + for &t in × { let (cx, cy) = self.at(t).unwrap_or((0.0, 0.0)); - times.push(t); raw_x.push(cx); raw_y.push(cy); } @@ -553,9 +559,7 @@ impl CursorTrack { // Une phase masquée coupe le ressort. Au retour, le curseur repart du premier point // réellement visible au lieu de traverser la trajectoire cachée avec du retard. A break // (a clip window's start) cuts it the same way. - let mut sorted_breaks: Vec = breaks.iter().copied().filter(|b| b.is_finite()).collect(); - sorted_breaks.sort_by(|a, b| a.partial_cmp(b).unwrap()); - let segment_of = |t: f32| sorted_breaks.partition_point(|&b| b <= t); + let segment_of = |t: f32| sorted_breaks.partition_point(|&b| b <= t + 1e-6); let mut xs = Vec::with_capacity(n); let mut ys = Vec::with_capacity(n); let mut run_start = 0; @@ -1261,4 +1265,21 @@ mod break_tests { assert!(lagging < 0.8, "without a break the spring still trails: {lagging}"); assert!((restarted - 0.9).abs() < 1e-3, "after a break it starts on the pointer: {restarted}"); } + + #[test] + fn a_break_between_grid_samples_restarts_exactly_on_it() { + // The clip starts at 2.001 s, off the 240 Hz grid: its first frame must already be on the + // pointer, not interpolated from the run before the break. + let samples: Vec<_> = (0..=120) + .map(|i| { + let t = i as f32 / 30.0; + (t, if t < 2.0 { 0.1 } else { 0.9 }, 0.5) + }) + .collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + let at_break = 2.001; + let target = raw.at(at_break).unwrap().0; + let restarted = raw.smoothed_with_breaks(0.5, &[at_break]).at(at_break).unwrap().0; + assert!((restarted - target).abs() < 1e-4, "{restarted} vs the pointer at {target}"); + } } diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs index e6410a815a..21df526721 100644 --- a/crates/compositor/src/live.rs +++ b/crates/compositor/src/live.rs @@ -936,9 +936,11 @@ fn reload_cursor_if_changed( true } -/// Where the spring of `screen_path`'s cursor track restarts (`Scene::cursor_breaks_for`). -fn cursor_breaks(scene: Option<&Scene>, screen_path: &str) -> Vec { - scene.map(|s| s.cursor_breaks_for(screen_path)).unwrap_or_default() +/// Where the cursor spring restarts while clip `clip_index` plays +/// (`Scene::cursor_break_for_clip`). It changes with the active clip, so the track is smoothed +/// again on a clip change even when the file stays the same: one spring pass over the recording. +fn cursor_breaks(scene: Option<&Scene>, clip_index: usize) -> Vec { + scene.and_then(|s| s.cursor_break_for_clip(clip_index)).into_iter().collect() } fn scene_for_clip(scene: &Scene, clip_index: usize) -> Scene { @@ -1820,7 +1822,7 @@ unsafe fn render_thread( // construction identique. Mesuré : 66 bascules sur un scrub de deux clips, // donc 66 relectures du même fichier. // The key also carries the clip's turn: the same file turned is another track. - let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); + let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); if reload_cursor_if_changed( &comp, &mut raw_cursor, @@ -1871,7 +1873,7 @@ unsafe fn render_thread( // change (pas à chaque frame — le resample+ressort parcourt tout l'enregistrement). // The clip breaks reshape it the same way, when the scene changes them. if let Some(raw) = &raw_cursor { - let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); + let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); if ip.cursor_smoothing != last_smoothing || breaks != last_breaks { comp.set_cursor(raw.smoothed_with_breaks(ip.cursor_smoothing, &breaks)); last_smoothing = ip.cursor_smoothing; @@ -1908,7 +1910,7 @@ unsafe fn render_thread( // here, mirrored the new way. let turned = scene.as_ref().is_some_and(Scene::screen_turned); comp.set_scene(scene); - let breaks = cursor_breaks(full_scene.as_ref(), &active_screen_path); + let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); if reload_cursor_if_changed( &comp, &mut raw_cursor, diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs index d27b20150c..6364ae9427 100644 --- a/crates/compositor/src/scene.rs +++ b/crates/compositor/src/scene.rs @@ -973,15 +973,23 @@ pub struct Scene { } impl Scene { - /// Where the cursor spring of `screen_path`'s track restarts: the source start of every clip - /// window on that file (`CursorTrack::smoothed_with_breaks`). A trim splits a clip into kept - /// segments, each a clip here, so the instant after a cut is a window start too. - pub fn cursor_breaks_for(&self, screen_path: &str) -> Vec { - self.clips - .iter() - .filter(|clip| clip.screen_path == screen_path) - .map(|clip| clip.source_start_sec as f32) - .collect() + /// Where the cursor spring restarts while clip `clip_index` plays + /// (`CursorTrack::smoothed_with_breaks`): its own source start, and nothing else. Another + /// clip's start on the same file is no cut in this one, so it must not reset this clip's + /// cursor mid-window. `None` when the clip before it is the same file ending exactly where + /// this one starts: the source runs on across that boundary (a split with nothing removed), + /// and a restart there would itself be a jump. The clips are addressed by index, as + /// everywhere else in the scene, so no path comparison picks the clip. + pub fn cursor_break_for_clip(&self, clip_index: usize) -> Option { + let clip = self.clips.get(clip_index)?; + let continues = clip_index + .checked_sub(1) + .and_then(|previous| self.clips.get(previous)) + .is_some_and(|previous| { + previous.screen_path.eq_ignore_ascii_case(&clip.screen_path) + && (previous.source_end_sec - clip.source_start_sec).abs() < 1e-3 + }); + (!continues).then_some(clip.source_start_sec as f32) } pub fn layout_at(&self, t: f32) -> Option> { @@ -1439,3 +1447,47 @@ mod annotation_tests { ); } } + +#[cfg(test)] +mod cursor_break_tests { + use super::*; + + fn scene_with_clips(clips: &[(&str, f64, f64)]) -> Scene { + let clips: Vec = clips + .iter() + .map(|(path, start, end)| { + format!( + r#"{{"screenPath":"{path}","webcamPath":"","sourceStartSec":{start},"sourceEndSec":{end},"webcamOffsetSec":0}}"# + ) + }) + .collect(); + let json = format!( + r##"{{"clips":[{}],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#000000"}},"zoomRegions":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##, + clips.join(",") + ); + Scene::from_json(&json).expect("scene") + } + + #[test] + fn each_clip_restarts_at_its_own_start_only() { + // A = [0, 6] and B = [2, 4] on one file: B's start is no cut inside A. + let scene = scene_with_clips(&[("a.mp4", 0.0, 6.0), ("a.mp4", 2.0, 4.0)]); + assert_eq!(scene.cursor_break_for_clip(0), Some(0.0)); + assert_eq!(scene.cursor_break_for_clip(1), Some(2.0)); + assert_eq!(scene.cursor_break_for_clip(2), None, "no such clip"); + } + + #[test] + fn a_clip_that_continues_the_one_before_it_does_not_restart() { + // A trim removed 4..6: the segment after the cut restarts, a plain split at 2 does not. + let scene = scene_with_clips(&[ + ("C:/Capture.mp4", 0.0, 2.0), + ("c:/capture.mp4", 2.0, 4.0), + ("C:/Capture.mp4", 6.0, 9.0), + ("other.mp4", 9.0, 12.0), + ]); + assert_eq!(scene.cursor_break_for_clip(1), None, "same file, source runs on"); + assert_eq!(scene.cursor_break_for_clip(2), Some(6.0), "footage was removed before it"); + assert_eq!(scene.cursor_break_for_clip(3), Some(9.0), "another file"); + } +} diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs index 090f10c381..3ef4f3bad2 100644 --- a/crates/compositor/src/timeline_walk.rs +++ b/crates/compositor/src/timeline_walk.rs @@ -350,6 +350,8 @@ unsafe fn walk_timeline( let cursor_enabled = scene.is_some(); let cursor_smoothing = scene.as_ref().map(|s| s.cursor.smoothing).unwrap_or(0.0); let mut cursor_tracks: HashMap = HashMap::new(); + // `None`: the file has no readable telemetry, so it is not read again for the next clip. + let mut raw_cursor_tracks: HashMap> = HashMap::new(); let mut cursor_active_path: Option = None; let mut frames: u64 = 0; @@ -506,17 +508,26 @@ unsafe fn walk_timeline( } if cursor_enabled { - // Keyed by file AND turn: the same file turned is another track. - let key = cursor_key(&clip.screen, turned); + // Keyed by file AND turn: the same file turned is another track. The raw file is read + // once; the smoothed track is also keyed by where this clip's spring restarts + // (`Scene::cursor_break_for_clip`, as in preview), so one clip's start never resets + // the cursor inside another clip on the same file. + let raw_key = cursor_key(&clip.screen, turned); + let clip_break = scene.as_ref().and_then(|s| s.cursor_break_for_clip(clip_index)); + let key = match clip_break { + Some(at) => format!("{raw_key}#{}", at.to_bits()), + None => raw_key.clone(), + }; if !cursor_tracks.contains_key(&key) { - let path = format!("{}.cursor.json", clip.screen); - if let Ok(raw) = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) { - let raw = if turned { raw.turned() } else { raw }; - // The spring restarts at every clip window on this file, as in preview. - let breaks = scene - .as_ref() - .map(|s| s.cursor_breaks_for(&clip.screen)) - .unwrap_or_default(); + if !raw_cursor_tracks.contains_key(&raw_key) { + let path = format!("{}.cursor.json", clip.screen); + let raw = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) + .ok() + .map(|raw| if turned { raw.turned() } else { raw }); + raw_cursor_tracks.insert(raw_key.clone(), raw); + } + if let Some(Some(raw)) = raw_cursor_tracks.get(&raw_key) { + let breaks: Vec = clip_break.into_iter().collect(); cursor_tracks.insert(key.clone(), raw.smoothed_with_breaks(cursor_smoothing, &breaks)); } // absente/illisible → pas d'entrée : ce clip s'exporte sans curseur (visible,