Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(gpui): index timeline snap targets once per drag
Himanshu Kumar13c89da34be7
diff --git a/apps/desktop-gpui/src/editor_window.rs b/apps/desktop-gpui/src/editor_window.rsindex ecbc4b425..f40c37897 100644--- a/apps/desktop-gpui/src/editor_window.rs+++ b/apps/desktop-gpui/src/editor_window.rs@@ -80,6 +80,7 @@ use crate::{mod frame;mod loading;mod scenes;+mod snap;// ---------------------------------------------------------------------------// Window geometry@@ -1458,7 +1459,7 @@ pub struct EditorWindow {minimap_drag: Option<timeline::MinimapDrag>,/// Magnetic edges for the live drag: playhead, clip cuts and every other/// segment's edges, gathered once when the drag arms.- drag_snap_targets: Vec<f64>,+ drag_snap_targets: snap::SnapTargets,/// The target the drag is currently snapped onto, for the guide line.drag_snap_time: Option<f64>,/// Blip-style ghost trim: while a clip handle drags, only this draft@@ -2099,7 +2100,7 @@ impl EditorWindow {clip_speed: None,timeline_scroll: gpui::ScrollHandle::new(),minimap_drag: None,- drag_snap_targets: Vec::new(),+ drag_snap_targets: snap::SnapTargets::default(),drag_snap_time: None,clip_draft: None,clip_anim: None,@@ -4801,7 +4802,7 @@ impl EditorWindow {targets.push(segment.end);}}- self.drag_snap_targets = targets;+ self.drag_snap_targets = snap::SnapTargets::new(targets);self.drag_snap_time = None;}@@ -4816,14 +4817,7 @@ impl EditorWindow {return (value, None);}let radius = DRAG_SNAP_PX * secs_per_pixel;- let mut best: Option<f64> = None;- for &target in &self.drag_snap_targets {- let distance = (target - value).abs();- if distance <= radius && best.is_none_or(|b| (b - value).abs() > distance) {- best = Some(target);- }- }- match best {+ match self.drag_snap_targets.nearest(value, radius) {Some(target) => (target, Some(target)),None => (value, None),}@@ -4868,22 +4862,14 @@ impl EditorWindow {let mut engaged = None;if !snap_disabled {let radius = DRAG_SNAP_PX * secs_per_pixel;- let mut best = f64::INFINITY;- for &target in &self.drag_snap_targets {- for edge in [start + raw, end + raw] {- let adjust = target - edge;- if adjust.abs() <= radius && adjust.abs() < best.abs() {- best = adjust;- engaged = Some(target);- }- }- }- if best.is_finite() {- let snapped = bounds.clamp(raw + best);- if (snapped - (raw + best)).abs() < 1e-9 {+ if let Some((adjustment, target)) =+ self.drag_snap_targets+ .move_adjustment(start + raw, end + raw, radius)+ {+ let snapped = bounds.clamp(raw + adjustment);+ if (snapped - (raw + adjustment)).abs() < 1e-9 {shift = snapped;- } else {- engaged = None;+ engaged = Some(target);}}}@@ -5902,7 +5888,7 @@ impl EditorWindow {/// select instead, which also moves the playhead/// (`props.handleUpdatePlayhead(e)`).fn drag_mouse_up(&mut self, window: &mut Window, cx: &mut Context<Self>) {- self.drag_snap_targets = Vec::new();+ self.drag_snap_targets = snap::SnapTargets::default();self.drag_snap_time = None;let Some(drag) = self.drag.take() else {self.clip_draft = None;diff --git a/apps/desktop-gpui/src/editor_window/snap.rs b/apps/desktop-gpui/src/editor_window/snap.rsnew file mode 100644index 000000000..78326a22e--- /dev/null+++ b/apps/desktop-gpui/src/editor_window/snap.rs@@ -0,0 +1,360 @@+const INDEX_MIN_TARGETS: usize = 32;++#[derive(Default)]+pub(super) struct SnapTargets {+ targets: Vec<Target>,+}++struct Target {+ time: f64,+ order: usize,+}++impl SnapTargets {+ pub(super) fn new(times: Vec<f64>) -> Self {+ let mut targets: Vec<_> = times+ .into_iter()+ .enumerate()+ .filter(|(_, time)| !time.is_nan())+ .map(|(order, time)| Target { time, order })+ .collect();+ if targets.len() >= INDEX_MIN_TARGETS {+ targets.sort_unstable_by(|left, right| left.time.total_cmp(&right.time));+ targets.dedup_by(|target, previous| {+ if target.time != previous.time {+ return false;+ }+ if target.order < previous.order {+ previous.time = target.time;+ previous.order = target.order;+ }+ true+ });+ }+ Self { targets }+ }++ pub(super) fn nearest(&self, value: f64, radius: f64) -> Option<f64> {+ self.nearest_target(value, radius)+ .map(|(target, _)| target.time)+ }++ pub(super) fn move_adjustment(&self, start: f64, end: f64, radius: f64) -> Option<(f64, f64)> {+ let mut best: Option<(f64, &Target)> = None;+ for edge in [start, end] {+ let Some((target, distance)) = self.nearest_target(edge, radius) else {+ continue;+ };+ if distance.is_finite()+ && best.is_none_or(|(adjustment, previous)| {+ distance < adjustment.abs()+ || (distance == adjustment.abs() && target.order < previous.order)+ })+ {+ best = Some((target.time - edge, target));+ }+ }+ best.map(|(adjustment, target)| (adjustment, target.time))+ }++ fn nearest_target(&self, value: f64, radius: f64) -> Option<(&Target, f64)> {+ if radius < 0.0 {+ return None;+ }+ let candidates =+ if self.targets.len() >= INDEX_MIN_TARGETS && value.is_finite() && radius.is_finite() {+ let split = self.targets.partition_point(|target| target.time < value);+ let nearest_distance = self.targets[..split]+ .last()+ .into_iter()+ .chain(self.targets[split..].first())+ .map(|target| (target.time - value).abs())+ .fold(f64::INFINITY, f64::min);+ if nearest_distance > radius {+ return None;+ }+ // Distinct timestamps can round to the same distance and retain their original priority.+ let mut start = split;+ while start > 0 && (self.targets[start - 1].time - value).abs() <= nearest_distance+ {+ start -= 1;+ }+ let mut end = split;+ while end < self.targets.len()+ && (self.targets[end].time - value).abs() <= nearest_distance+ {+ end += 1;+ }+ &self.targets[start..end]+ } else {+ &self.targets+ };+ let mut best: Option<(&Target, f64)> = None;+ for target in candidates {+ let distance = (target.time - value).abs();+ if distance <= radius+ && best.is_none_or(|(previous, previous_distance)| {+ distance < previous_distance+ || (distance == previous_distance && target.order < previous.order)+ })+ {+ best = Some((target, distance));+ }+ }+ best+ }+}++#[cfg(test)]+mod tests {+ use super::{INDEX_MIN_TARGETS, SnapTargets};++ fn indexed_targets(times: Vec<f64>) -> SnapTargets {+ SnapTargets::new(+ times+ .into_iter()+ .chain((0..INDEX_MIN_TARGETS).map(|index| -1_000_000.0 - index as f64))+ .collect(),+ )+ }++ fn linear_nearest(targets: &[f64], value: f64, radius: f64) -> Option<f64> {+ let mut best: Option<f64> = None;+ for &target in targets {+ let distance = (target - value).abs();+ if distance <= radius && best.is_none_or(|previous| (previous - value).abs() > distance)+ {+ best = Some(target);+ }+ }+ best+ }++ fn linear_move(targets: &[f64], start: f64, end: f64, radius: f64) -> Option<(f64, f64)> {+ let mut best = f64::INFINITY;+ let mut engaged = None;+ for &target in targets {+ for edge in [start, end] {+ let adjust = target - edge;+ if adjust.abs() <= radius && adjust.abs() < best.abs() {+ best = adjust;+ engaged = Some(target);+ }+ }+ }+ engaged.map(|target| (best, target))+ }++ fn move_bits(result: Option<(f64, f64)>) -> Option<(u64, u64)> {+ result.map(|(adjustment, target)| (adjustment.to_bits(), target.to_bits()))+ }++ #[test]+ fn nearest_preserves_target_order_for_equal_distances() {+ let targets = indexed_targets(vec![12.0, 8.0, 8.0]);+ assert_eq!(targets.nearest(10.0, 2.0), Some(12.0));+ assert_eq!(targets.nearest(10.0, 1.0), None);+ assert_eq!(targets.nearest(8.0, 0.0), Some(8.0));+ assert_eq!(targets.nearest(8.0, -1.0), None);+ assert_eq!(SnapTargets::default().nearest(8.0, 2.0), None);+ }++ #[test]+ fn moves_prioritize_target_order_then_the_start_edge() {+ assert_eq!(+ indexed_targets(vec![16.0, 10.0]).move_adjustment(9.0, 15.0, 1.0),+ Some((1.0, 16.0))+ );+ assert_eq!(+ indexed_targets(vec![10.0]).move_adjustment(9.0, 11.0, 1.0),+ Some((1.0, 10.0))+ );+ }++ #[test]+ fn rounded_radius_boundaries_remain_inclusive() {+ let lower = f64::from_bits(0.5_f64.to_bits() - 1);+ assert!(lower < 1.0 - 0.5);+ assert_eq!(1.0 - lower, 0.5);+ assert_eq!(indexed_targets(vec![lower]).nearest(1.0, 0.5), Some(lower));+ let upper = -lower;+ assert_eq!(indexed_targets(vec![upper]).nearest(-1.0, 0.5), Some(upper));+ }++ #[test]+ fn rounded_distance_ties_can_span_distinct_targets() {+ let value = 2_f64.powi(55);+ let targets = indexed_targets(vec![0.0, 1.0, 2.0]);+ assert_eq!(targets.nearest(value, value), Some(0.0));+ assert_eq!(+ targets.move_adjustment(value, value, value),+ Some((-value, 0.0))+ );+ }++ #[test]+ fn signed_zero_keeps_the_original_target_bits() {+ for times in [vec![0.0, -0.0], vec![-0.0, 0.0]] {+ let targets = indexed_targets(times.clone());+ for value in [0.0, -0.0] {+ assert_eq!(+ targets.nearest(value, 0.0).map(f64::to_bits),+ Some(times[0].to_bits())+ );+ assert_eq!(+ move_bits(targets.move_adjustment(value, -value, 0.0)),+ move_bits(linear_move(×, value, -value, 0.0))+ );+ }+ }+ }++ #[test]+ fn extreme_values_match_the_original_scans() {+ let values = [+ f64::NAN,+ f64::INFINITY,+ f64::NEG_INFINITY,+ f64::MAX,+ f64::MIN,+ -1.0,+ -f64::MIN_POSITIVE,+ -0.0,+ 0.0,+ f64::MIN_POSITIVE,+ f64::from_bits(1),+ 1.0,+ ];+ for offset in 0..values.len() {+ let mut times = values.to_vec();+ times.rotate_left(offset);+ times.extend((0..INDEX_MIN_TARGETS).map(|index| -1_000_000.0 - index as f64));+ let targets = SnapTargets::new(times.clone());+ for value in values {+ for radius in values {+ assert_eq!(+ targets.nearest(value, radius).map(f64::to_bits),+ linear_nearest(×, value, radius).map(f64::to_bits)+ );+ assert_eq!(+ move_bits(targets.move_adjustment(value, -value, radius)),+ move_bits(linear_move(×, value, -value, radius))+ );+ }+ }+ }+ }++ #[test]+ fn indexed_lookups_match_the_original_scans_for_varied_timelines() {+ let mut state = 0x5c7e_42b1_09a3_d6f8_u64;+ let mut next = || {+ state = state.wrapping_mul(6364136223846793005).wrapping_add(1);+ state+ };+ for count in [0, 1, 2, 16, 31, 32, 33, 128, 1024] {+ let times: Vec<_> = (0..count).map(|_| (next() % 12000) as f64 / 20.0).collect();+ let targets = SnapTargets::new(times.clone());+ for _ in 0..200 {+ let start = (next() % 12000) as f64 / 20.0;+ let end = start + (next() % 200) as f64 / 20.0;+ let radius = (next() % 200) as f64 / 100.0;+ assert_eq!(+ targets.nearest(start, radius).map(f64::to_bits),+ linear_nearest(×, start, radius).map(f64::to_bits)+ );+ assert_eq!(+ move_bits(targets.move_adjustment(start, end, radius)),+ move_bits(linear_move(×, start, end, radius))+ );+ }+ }+ }++ #[test]+ #[ignore]+ fn benchmark_drag_snapping() {+ use std::{hint::black_box, time::Instant};+ println!("targets,duration,queries,radius,movement,sample,before_ns,after_ns");+ for (count, duration, queries, radius) in [+ (8usize, 600., 120, 0.08),+ (32, 600., 120, 4.8),+ (256, 600., 120, 4.8),+ (2048, 600., 120, 4.8),+ (16384, 3600., 240, 28.8),+ ] {+ let mut times = vec![0., duration * 0.47, duration];+ times.extend((3..count).map(|i| {+ let position = (i * 7919) % count;+ let position = if i.is_multiple_of(19) {+ position / 8 * 8+ } else {+ position+ };+ duration * position as f64 / count as f64+ }));+ let values: Vec<_> = (0..queries)+ .map(|i| duration * 0.4 + duration * 0.15 * (i as f64 / (queries - 1) as f64 - 0.5))+ .collect();+ let targets = SnapTargets::new(times.clone());+ for &value in &values {+ assert_eq!(+ targets.nearest(value, radius).map(f64::to_bits),+ linear_nearest(×, value, radius).map(f64::to_bits)+ );+ assert_eq!(+ move_bits(targets.move_adjustment(value, value + 5., radius)),+ move_bits(linear_move(×, value, value + 5., radius))+ );+ }+ for movement in [false, true] {+ let run = |indexed| {+ let start = Instant::now();+ if indexed {+ let targets = SnapTargets::new(black_box(times.clone()));+ for &value in &values {+ if movement {+ black_box(targets.move_adjustment(+ black_box(value),+ value + 5.,+ radius,+ ));+ } else {+ black_box(targets.nearest(black_box(value), radius));+ }+ }+ } else {+ let targets = black_box(times.clone());+ for &value in &values {+ if movement {+ black_box(linear_move(+ &targets,+ black_box(value),+ value + 5.,+ radius,+ ));+ } else {+ black_box(linear_nearest(&targets, black_box(value), radius));+ }+ }+ }+ start.elapsed().as_nanos()+ };+ for sample in 0..35 {+ let (before, after) = if sample % 2 == 0 {+ (run(false), run(true))+ } else {+ let after = run(true);+ (run(false), after)+ };+ if sample >= 5 {+ println!(+ "{count},{duration},{queries},{radius},{movement},{},{before},{after}",+ sample - 5+ );+ }+ }+ }+ }+ }+}