From aa57cc80b9c0fe4ffa9a348ea9701b179dccc2ae Mon Sep 17 00:00:00 2001 From: Gustavo Ziger Date: Sun, 11 Oct 2026 15:41:14 -0300 Subject: [PATCH] feat: animate zoom changes (#566) --- contributors/people.toml | 3 + crates/ui-egui/src/actions.rs | 9 +- crates/ui-egui/src/artboard_ui.rs | 2 + crates/ui-egui/src/canvas.rs | 181 +++++++++++++++++++++-- crates/ui-egui/src/canvas_tool_menu.rs | 26 ++++ crates/ui-egui/src/chrome_ui.rs | 2 + crates/ui-egui/src/control.rs | 4 + crates/ui-egui/src/crop_ui.rs | 13 +- crates/ui-egui/src/move_outline_tests.rs | 13 +- crates/ui-egui/src/panels.rs | 24 +++ crates/ui-egui/src/preset_panels.rs | 13 +- crates/ui-egui/src/scrollbars.rs | 26 +++- crates/ui-egui/src/state.rs | 31 +++- crates/ui-egui/src/view_cmds.rs | 10 ++ crates/ui-egui/src/zoom_tool.rs | 150 +++++++++++++++++++ docs/ui-parity.md | 5 +- 16 files changed, 493 insertions(+), 19 deletions(-) diff --git a/contributors/people.toml b/contributors/people.toml index 0c8aa6fb09..a3cf9d5667 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -106,3 +106,6 @@ display_name = "SyntaxError" [people.axlecoffee] sync_github_name = true + +[people.zi-ger] +sync_github_name = true diff --git a/crates/ui-egui/src/actions.rs b/crates/ui-egui/src/actions.rs index cf06940224..30ccf04317 100644 --- a/crates/ui-egui/src/actions.rs +++ b/crates/ui-egui/src/actions.rs @@ -142,21 +142,28 @@ pub(crate) fn run_view(app: &mut PhotocraftApp, id: &str, params: Value) -> Resu let v = app.ui.views.get_mut(i).ok_or("no document view")?; v.fill_pending = false; match id { - "view.fitOnScreen" => v.fit_pending = true, + "view.fitOnScreen" => { + v.fit_pending = true; + v.zoom_animating = true; + } "view.zoomIn" => { v.fit_pending = false; v.zoom = crate::zoom_levels::step(v.zoom, 1, v.doc_size); + v.zoom_animating = true; } "view.zoomOut" => { v.fit_pending = false; v.zoom = crate::zoom_levels::step(v.zoom, -1, v.doc_size); + v.zoom_animating = true; } "view.actualPixels" => { v.fit_pending = false; v.zoom = 1.0; + v.zoom_animating = true; } _ => return Err(format!("unsupported view command: {id}")), } + v.zoom_anchor = None; app.session.journal.push((id.into(), params)); Ok(Value::Null) } diff --git a/crates/ui-egui/src/artboard_ui.rs b/crates/ui-egui/src/artboard_ui.rs index 1ff452a829..1dda153ff2 100644 --- a/crates/ui-egui/src/artboard_ui.rs +++ b/crates/ui-egui/src/artboard_ui.rs @@ -73,6 +73,8 @@ pub fn fit_artboard(app: &mut PhotocraftApp) -> Result { // overflows an i32 sum (#981). v.center = [((f64::from(b.x0) + f64::from(b.x1)) / 2.0) as f32, ((f64::from(b.y0) + f64::from(b.y1)) / 2.0) as f32]; v.fit_pending = false; + v.zoom_animating = true; + v.zoom_anchor = None; Ok(json!({"zoom": v.zoom, "artboard": id.0, "bounds": [b.x0, b.y0, b.x1, b.y1]})) } diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index fbac6ce436..845b26750b 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -787,10 +787,11 @@ impl ViewXform { /// The main canvas's mapping for the active document as last laid out (inside the rulers). pub fn active(app: &PhotocraftApp) -> Option { let v = app.ui.views.get(app.session.active_index()?)?; + let (zoom, center) = if v.zoom_animating { v.display_camera.unwrap_or((v.zoom, v.center)) } else { (v.zoom, v.center) }; Some(Self { rect: crate::rulers::content_rect(app, app.last_canvas_rect), - zoom: v.zoom / app.canvas_ppp(), - center: v.center, + zoom: zoom / app.canvas_ppp(), + center, flip: app.ui.view.flip_horizontal, rotation: v.rotation, aspect: app.ui.view.display_aspect(), @@ -878,6 +879,119 @@ pub fn fit_view(view: &mut View, doc: &Document, area: Vec2, ppp: f32, aspect: f view.fill_pending = false; } +/// Ease a transient presentation camera over 220 ms without changing the requested camera. +fn animated_view(view: &mut View, xf: ViewXform, ppp: f32, time: f64) -> View { + let target = (view.zoom, view.center); + // Clamping, a canvas resize, or another camera command can make the original anchor + // incompatible with the requested camera. The target must always win. + if let Some((doc, screen)) = view.zoom_anchor { + let offset = xf.unmap_vec((pos2(screen[0], screen[1]) - xf.rect.center()) / (view.zoom / ppp)); + if (doc[0] as f32 - offset.x - view.center[0]).abs() > 0.01 || (doc[1] as f32 - offset.y - view.center[1]).abs() > 0.01 { + view.zoom_anchor = None; + } + } + let mut shown = view.clone(); + if view.zoom_animating { + if view.zoom_transition.is_none_or(|a| a.target != target) { + view.zoom_transition = Some(crate::state::ZoomTransition { from: view.display_camera.unwrap_or(target), target, started: time }); + } + if let Some(a) = view.zoom_transition { + let elapsed = (time - a.started) / 0.22; + let t = if elapsed.is_finite() { elapsed.clamp(0.0, 1.0) as f32 } else { 1.0 }; + let ease = t * t * (3.0 - 2.0 * t); + let lerp = |from: f32, to: f32| from + (to - from) * ease; + shown.zoom = lerp(a.from.0, target.0); + shown.center = [lerp(a.from.1[0], target.1[0]), lerp(a.from.1[1], target.1[1])]; + if let Some((doc, screen)) = view.zoom_anchor { + let zoom = shown.zoom / ppp; + if zoom.is_finite() && zoom > 0.0 { + let offset = xf.unmap_vec((pos2(screen[0], screen[1]) - xf.rect.center()) / zoom); + shown.center = [doc[0] as f32 - offset.x, doc[1] as f32 - offset.y]; + } + } + if t >= 1.0 { + view.zoom_animating = false; + } + } + } + if !view.zoom_animating { + shown.zoom = target.0; + shown.center = target.1; + view.zoom_anchor = None; + view.zoom_transition = None; + } + view.display_camera = Some((shown.zoom, shown.center)); + shown +} + +#[cfg(test)] +mod zoom_animation_tests { + use super::*; + + fn camera(view: &View) -> ViewXform { + ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(1000.0, 700.0)), zoom: view.zoom, center: view.center, flip: false, rotation: 0.0, aspect: 1.0 } + } + + fn view() -> View { + View { zoom: 1.0, center: [200.0, 150.0], doc_size: [400, 300], fit_pending: false, ..Default::default() } + } + + #[test] + fn zoom_animation_obeys_clamped_targets_and_eases_recentering() { + let mut v = view(); + let xf = camera(&v); + animated_view(&mut v, xf, 1.0, 0.0); + let pointer = xf.to_screen(390.0, 150.0); + zoom_about(&mut v, &xf, pointer, 2.0, false, 1.0); + v.zoom_anchor = Some(([390.0, 150.0], [pointer.x, pointer.y])); + v.zoom_animating = true; + crate::scrollbars::clamp_view(&mut v, xf.rect.size(), 1.0); + let xf = camera(&v); + animated_view(&mut v, xf, 1.0, 0.0); + assert!(v.zoom_anchor.is_none()); + let done = animated_view(&mut v, xf, 1.0, 0.22); + assert_eq!((done.zoom, done.center), (v.zoom, v.center)); + assert!(!v.zoom_animating); + + let mut v = view(); + let xf = camera(&v); + animated_view(&mut v, xf, 1.0, 0.0); + zoom_about(&mut v, &xf, pointer, 2.0, true, 1.0); + v.zoom_animating = true; + let target = v.center; + let xf = camera(&v); + let start = animated_view(&mut v, xf, 1.0, 0.0); + assert_eq!(start.center, [200.0, 150.0], "recentering must not teleport"); + let halfway = animated_view(&mut v, xf, 1.0, 0.11); + assert!(halfway.center[0] > start.center[0] && halfway.center[0] < target[0]); + assert_eq!(animated_view(&mut v, xf, 1.0, 0.22).center, target); + } + + #[test] + fn zoom_animation_views_are_independent_and_direct_navigation_snaps() { + let mut a = view(); + let mut b = view(); + let xf = camera(&a); + animated_view(&mut a, xf, 1.0, 0.0); + animated_view(&mut b, xf, 1.0, 0.0); + a.zoom = 2.0; + a.zoom_animating = true; + animated_view(&mut a, xf, 1.0, 0.0); + b.zoom = 3.0; + b.zoom_animating = true; + animated_view(&mut b, xf, 1.0, 0.11); + assert_eq!(animated_view(&mut a, xf, 1.0, 0.22).zoom, 2.0); + let shown = animated_view(&mut b, xf, 1.0, 0.22); + assert!(shown.zoom > 1.0 && shown.zoom < 3.0); + assert!(b.zoom_animating && !a.zoom_animating); + b.zoom_animating = false; + b.center = [220.0, 170.0]; + let shown = animated_view(&mut b, xf, 1.0, 0.23); + assert_eq!((shown.zoom, shown.center), (b.zoom, b.center)); + assert!(b.zoom_transition.is_none() && b.zoom_anchor.is_none()); + } +} + /// Centre the document and zoom until it fills the canvas. One axis can extend beyond the /// viewport, matching the Hand tool's Fill Screen action. pub fn fill_view(view: &mut View, doc: &Document, area: Vec2, ppp: f32, aspect: f32) { @@ -2470,6 +2584,26 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: } let full = rect; let rect = if primary { crate::rulers::content_rect(app, rect) } else { rect }; + // Direct navigation starts from the authoritative camera. This also means a click or drag + // never maps through a camera that is still moving under the pointer. + let (pointer_here, hover_here) = ctx.input(|i| { + ( + (i.pointer.any_pressed() || i.pointer.any_down()) && i.pointer.press_origin().is_some_and(|p| rect.contains(p)), + i.pointer.hover_pos().is_some_and(|p| rect.contains(p)), + ) + }); + let direct_input = pointer_here + || (hover_here + && crate::wheel_nav::read( + &ctx, + app.session.prefs().general.zoom_with_scroll_wheel, + app.session.prefs().enhanced_controls.zoom_with_trackpad_pinch, + ) + .is_some()); + if direct_input { + view.zoom_animating = false; + view.zoom_anchor = None; + } let doc = app.session.documents()[idx].doc.clone(); let size = [doc.size.width, doc.size.height]; if view.doc_size != size { @@ -2489,12 +2623,23 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: } // Preferences › Tools › Overscroll off: clamp before anything is drawn (scrollbars.rs). if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view(&mut view, rect.size() / vec2(aspect, 1.0), ppp) { + view.zoom_anchor = None; ctx.request_repaint(); } let flip = app.ui.view.flip_horizontal; - // Canvas geometry (ViewXform, ViewParams, painter rects) is in egui points. - let point_zoom = view.zoom / ppp; - let xf = ViewXform { rect, zoom: point_zoom, center: view.center, flip, rotation: view.rotation, aspect }; + // Document rendering follows the target; only shader uniforms and overlay geometry ease. + let target_xf = ViewXform { rect, zoom: view.zoom / ppp, center: view.center, flip, rotation: view.rotation, aspect }; + let render_zoom = view.zoom; + let render_visible = visible_doc_rect(&target_xf); + let mut display_view = animated_view(&mut view, target_xf, ppp, ctx.input(|i| i.time)); + if primary && let Some(stored) = app.ui.views.get_mut(idx) { + stored.zoom_animating = view.zoom_animating; + stored.display_camera = view.display_camera; + } + if view.zoom_animating { + ctx.request_repaint(); + } + let xf = ViewXform { zoom: display_view.zoom / ppp, center: display_view.center, ..target_xf }; let pixel_grid = app.ui.view.shows(app.ui.view.show.pixel_grid); let response = ui.allocate_rect(rect, Sense::click_and_drag()); let stroke_dismissal = primary && crate::shape_stroke_ui::dismiss_from_canvas(app, &response); @@ -2535,7 +2680,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: if app.gpu.is_some() && gpu_ok && let Some((k, key, preview_size)) = - ensure_adjust_proxy(app, idx, view.zoom).or_else(|| ensure_filter_preview(app, idx, &ctx)).or_else(|| ensure_proxy_preview(app, idx)) + ensure_adjust_proxy(app, idx, render_zoom).or_else(|| ensure_filter_preview(app, idx, &ctx)).or_else(|| ensure_proxy_preview(app, idx)) { on_gpu = true; let original_size = [doc.size.width.div_ceil(k), doc.size.height.div_ceil(k)]; @@ -2561,7 +2706,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: offset: [0.0, 0.0], }; paint_gpu_view(&painter, rect, params, &pattern); - } else if gpu_ok && ensure_gpu(app, idx, visible_doc_rect(&xf)) { + } else if gpu_ok && ensure_gpu(app, idx, render_visible) { on_gpu = true; app.perf.gpu = true; // Shadow, checkerboard, document and pixel grid in one custom shader (gpu_canvas.rs). @@ -2727,7 +2872,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: (img_rect, beyond, layer_edges) }; - let painted = if crop_camera { None } else { Some(paint_canvas(app, ui, &view, xf)) }; + let painted = if crop_camera { None } else { Some(paint_canvas(app, ui, &display_view, xf)) }; let img_rect = xf.doc_rect(doc.bounds()); // Under an open dialog the canvas widget is inert, but the image still pans and zooms. @@ -2759,6 +2904,8 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: } let rotate_trackpad = app.session.prefs().enhanced_controls.rotate_view_with_trackpad; if let Some(delta) = crate::rotate_view::trackpad_delta(&ctx, rotate_trackpad) { + view.zoom_animating = false; + view.zoom_anchor = None; let next = view.rotation + delta; if next.is_finite() { view.rotation = crate::rotate_view::wrap_deg(next); @@ -2871,6 +3018,8 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: if let Some(d) = crate::flick_pan::frame(&ctx, flick_id, hand_pan && response.dragged() && !stroke_dismissal, response.drag_delta(), flick_on) { let d = xf.unmap_vec(d) / (view.zoom / ppp); if d.is_finite() { + view.zoom_animating = false; + view.zoom_anchor = None; view.center[0] -= d.x; view.center[1] -= d.y; } @@ -3121,7 +3270,11 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: Tool::Zoom => { let nz = crate::zoom_levels::step(view.zoom, if zoom_out(click_mods.alt) { -1 } else { 1 }, view.doc_size); let center = app.session.prefs().tools.zoom_clicked_point_to_center; + let doc_anchor = xf.to_doc(p); + let screen_anchor = p; zoom_about(&mut view, &xf, p, nz, center, ppp); + view.zoom_animating = nz != display_view.zoom; + view.zoom_anchor = (view.zoom_animating && !center).then_some((doc_anchor, [screen_anchor.x, screen_anchor.y])); } // A click with the (temporary) Hand does nothing, never the tool underneath. Tool::Hand | Tool::RotateView => {} @@ -3189,8 +3342,16 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect: ctx.request_repaint(); } } - let xf = if crop_camera { ViewXform { center: view.center, rotation: view.rotation, ..xf } } else { xf }; - let (img_rect, beyond, layer_edges) = painted.unwrap_or_else(|| paint_canvas(app, ui, &view, xf)); + let xf = if crop_camera { + if view.center != target_xf.center { + display_view.center = view.center; + } + display_view.rotation = view.rotation; + ViewXform { center: display_view.center, rotation: display_view.rotation, ..xf } + } else { + xf + }; + let (img_rect, beyond, layer_edges) = painted.unwrap_or_else(|| paint_canvas(app, ui, &display_view, xf)); if primary && !(hand_pan && response.dragged()) { if app.ui.extras.grid && app.ui.view.extras { crate::rulers::draw_grid(app, &painter, &xf, &doc); diff --git a/crates/ui-egui/src/canvas_tool_menu.rs b/crates/ui-egui/src/canvas_tool_menu.rs index 5674e909bf..c14a93c487 100644 --- a/crates/ui-egui/src/canvas_tool_menu.rs +++ b/crates/ui-egui/src/canvas_tool_menu.rs @@ -480,6 +480,8 @@ fn choose_view(app: &mut PhotocraftApp, ctx: &Context, menu: &CanvasToolMenu, co let v = app.ui.views.get_mut(i).ok_or("no document view")?; v.fit_pending = false; v.fill_pending = true; + v.zoom_animating = true; + v.zoom_anchor = None; return Ok(()); } let before = app.ui.views.get(i).map(|v| (v.zoom, v.center)); @@ -495,6 +497,7 @@ fn choose_view(app: &mut PhotocraftApp, ctx: &Context, menu: &CanvasToolMenu, co // from the centre shrinks (or grows) by the zoom ratio, whatever the rotation or flip. let ratio = zoom0 / v.zoom; v.center = if center_on_point || !ratio.is_finite() { d } else { [d[0] - (d[0] - c[0]) * ratio, d[1] - (d[1] - c[1]) * ratio] }; + v.zoom_anchor = (!center_on_point).then_some(([d[0] as f64, d[1] as f64], menu.pos)); Ok(()) } @@ -1124,6 +1127,29 @@ mod tests { assert!((screen_of(h.state(), doc) - p).length() < 1.0); } + #[test] + fn view_menu_zoom_keeps_its_anchor_during_the_animation() { + let mut app = zoom_app(400, 300); + app.ui.tool = Tool::Zoom; + let mut h = harness(app); + let zoom = h.state().ui.views[0].zoom; + let doc = [300.0, 100.0]; + let p = screen_of(h.state(), doc); + right_click(&mut h, p, Modifiers::NONE); + let ctx = h.ctx.clone(); + // Choose without the widget click helper, which runs repaint frames until settled. + choose(h.state_mut(), &ctx, "view.zoomIn"); + h.step(); + h.input_mut().time = Some(ctx.input(|i| i.time) + 0.11); + h.step(); + let displayed = crate::canvas::ViewXform::active(h.state()).unwrap(); + assert!(displayed.zoom > zoom && displayed.zoom < h.state().ui.views[0].zoom); + assert!(displayed.to_screen(doc[0], doc[1]).distance(p) < 1.0); + h.input_mut().time = Some(ctx.input(|i| i.time) + 0.3); + h.step(); + assert!(!h.state().ui.views[0].zoom_animating); + } + #[test] fn view_menu_zoom_in_centres_the_clicked_point_with_the_preference() { let mut app = zoom_app(400, 300); diff --git a/crates/ui-egui/src/chrome_ui.rs b/crates/ui-egui/src/chrome_ui.rs index 81cf0fce54..80b16525ee 100644 --- a/crates/ui-egui/src/chrome_ui.rs +++ b/crates/ui-egui/src/chrome_ui.rs @@ -151,6 +151,8 @@ pub fn status_bar_pro(app: &mut PhotocraftApp, ui: &mut egui::Ui) { let control_h = crate::panels::status_bar_heights(&t).1; if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 64.0, control_h).changed() { app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size); + app.ui.views[i].zoom_animating = false; + app.ui.views[i].zoom_anchor = None; app.ui.views[i].fit_pending = false; } ui.add_space(12.0); diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index fde3f0b2cb..1f0ab6b55e 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -651,6 +651,10 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest) crate::panels::request_dock_width(ctx, w as f32); } if let Some(i) = app.session.active_index() { + if zoom.is_some() || center.is_some() || rotation.is_some() || fit { + app.ui.views[i].zoom_animating = false; + app.ui.views[i].zoom_anchor = None; + } if let Some(z) = zoom { let size = app.session.documents().get(i).map_or([0, 0], |st| [st.doc.size.width, st.doc.size.height]); app.ui.views[i].zoom = crate::zoom_levels::clamp(z as f32, size); diff --git a/crates/ui-egui/src/crop_ui.rs b/crates/ui-egui/src/crop_ui.rs index 8b67459c42..0245c41924 100644 --- a/crates/ui-egui/src/crop_ui.rs +++ b/crates/ui-egui/src/crop_ui.rs @@ -1231,7 +1231,18 @@ mod tests { fn space_on_the_canvas_moves_the_frame_not_the_view() { use egui::{Event, Key, PointerButton, pos2}; let mut a = app(SampleType::U8); - let view = crate::state::View { zoom: 2.0, center: [100.0, 50.0], fit_pending: false, fill_pending: false, doc_size: [200, 100], rotation: 0.0 }; + let view = crate::state::View { + zoom: 2.0, + center: [100.0, 50.0], + fit_pending: false, + fill_pending: false, + doc_size: [200, 100], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + }; a.ui.views = vec![view.clone()]; let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(600.0, 400.0)).build_ui_state( |ui, app: &mut PhotocraftApp| { diff --git a/crates/ui-egui/src/move_outline_tests.rs b/crates/ui-egui/src/move_outline_tests.rs index 7029ab9faf..48808b089f 100644 --- a/crates/ui-egui/src/move_outline_tests.rs +++ b/crates/ui-egui/src/move_outline_tests.rs @@ -38,7 +38,18 @@ fn app() -> (PhotocraftApp, LayerId, LayerId) { app.ui.view.extras = true; app.ui.view.show.layer_edges = true; // 4 screen px per document px, the document centred. - app.ui.views = vec![View { zoom: 4.0, center: [32.0, 32.0], fit_pending: false, fill_pending: false, doc_size: [64, 64], rotation: 0.0 }]; + app.ui.views = vec![View { + zoom: 4.0, + center: [32.0, 32.0], + fit_pending: false, + fill_pending: false, + doc_size: [64, 64], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + }]; (app, ids[0], ids[1]) } diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs index 3afff0f399..a2ec65a9ae 100644 --- a/crates/ui-egui/src/panels.rs +++ b/crates/ui-egui/src/panels.rs @@ -1332,11 +1332,17 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) { && let Some(i) = app.session.active_index() { app.ui.views[i].fit_pending = true; + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; } if widgets::secondary_button(ui, "100%", 0.0).clicked() && let Some(i) = app.session.active_index() { app.ui.views[i].zoom = 1.0; + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; + app.ui.views[i].fit_pending = false; + app.ui.views[i].fill_pending = false; } } Tool::RotateView => { @@ -1362,6 +1368,8 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) { && let Some(i) = app.session.active_index() { app.ui.views[i].zoom = 1.0; + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; app.ui.views[i].fit_pending = false; app.ui.views[i].fill_pending = false; } @@ -1369,12 +1377,16 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) { && let Some(i) = app.session.active_index() { app.ui.views[i].fit_pending = true; + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; app.ui.views[i].fill_pending = false; } if widgets::secondary_button(ui, tl!("Fill Screen"), 0.0).clicked() && let Some(i) = app.session.active_index() { app.ui.views[i].fill_pending = true; + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; app.ui.views[i].fit_pending = false; } } @@ -1531,6 +1543,8 @@ pub fn status_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) { let mut pct = app.ui.views[i].zoom * 100.0; if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 78.0, control_h).changed() { app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size); + app.ui.views[i].zoom_animating = false; + app.ui.views[i].zoom_anchor = None; app.ui.views[i].fit_pending = false; } widgets::vline(ui, 16.0); @@ -1808,6 +1822,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) { { let d = (pp - rect.min) / s; app.ui.views[idx].center = [d.x.clamp(0.0, size.width as f32), d.y.clamp(0.0, size.height as f32)]; + app.ui.views[idx].zoom_animating = false; + app.ui.views[idx].zoom_anchor = None; app.ui.views[idx].fit_pending = false; } // The Navigator has its own zoom target: an unmodified wheel over the preview @@ -1822,6 +1838,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) { let next = crate::zoom_levels::clamp(view.zoom * factor, view.doc_size); if next != view.zoom { view.zoom = next; + view.zoom_animating = false; + view.zoom_anchor = None; view.fit_pending = false; } } @@ -1843,11 +1861,15 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) { for (lbl, z) in [("200%", 2.0), ("100%", 1.0)] { if widgets::pill_tab(ui, lbl, (v.zoom - z).abs() < 1e-3).clicked() { app.ui.views[idx].zoom = z; + app.ui.views[idx].zoom_animating = true; + app.ui.views[idx].zoom_anchor = None; app.ui.views[idx].fit_pending = false; } } if widgets::pill_tab(ui, tl!("Fit"), false).clicked() { app.ui.views[idx].fit_pending = true; + app.ui.views[idx].zoom_animating = true; + app.ui.views[idx].zoom_anchor = None; } }); }); @@ -1856,6 +1878,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) { let mut lz = v.zoom.log2(); if lz.is_finite() && widgets::slider(ui, &mut lz, lo..=hi, None).changed() { app.ui.views[idx].zoom = crate::zoom_levels::clamp(2f32.powf(lz), v.doc_size); + app.ui.views[idx].zoom_animating = false; + app.ui.views[idx].zoom_anchor = None; app.ui.views[idx].fit_pending = false; } }); diff --git a/crates/ui-egui/src/preset_panels.rs b/crates/ui-egui/src/preset_panels.rs index 17737dec15..8e4f8aca96 100644 --- a/crates/ui-egui/src/preset_panels.rs +++ b/crates/ui-egui/src/preset_panels.rs @@ -1171,7 +1171,18 @@ mod tests { fn preset_drops_map_through_the_ruler_inset() { let (mut app, _) = app(); app.last_canvas_rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0)); - app.ui.views[0] = crate::state::View { zoom: 2.0, center: [32.0, 24.0], fit_pending: false, fill_pending: false, doc_size: [64, 48], rotation: 0.0 }; + app.ui.views[0] = crate::state::View { + zoom: 2.0, + center: [32.0, 24.0], + fit_pending: false, + fill_pending: false, + doc_size: [64, 48], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + }; let p = egui::pos2(400.0, 300.0); let off = crate::canvas::doc_point_at(&app, p).unwrap(); assert_eq!(off, [32.0, 24.0], "without rulers the widget rect is the whole mapping"); diff --git a/crates/ui-egui/src/scrollbars.rs b/crates/ui-egui/src/scrollbars.rs index 2ab7cdeab6..dde52d1181 100644 --- a/crates/ui-egui/src/scrollbars.rs +++ b/crates/ui-egui/src/scrollbars.rs @@ -289,7 +289,18 @@ mod tests { assert_eq!(clamp_axis(-400.0, 1000.0, 500.0, 0.2), -250.0, "the image's right edge on the view's"); assert_eq!(clamp_axis(1400.0, 1000.0, 500.0, 0.2), 1250.0, "its left edge on the view's"); assert_eq!(clamp_axis(500.0, 1000.0, 1000.0, 1.0), 500.0, "exactly the view's size: centred"); - let mut v = View { zoom: 1.0, center: [-500.0, 20.0], fit_pending: false, fill_pending: false, doc_size: [1000, 800], rotation: 0.0 }; + let mut v = View { + zoom: 1.0, + center: [-500.0, 20.0], + fit_pending: false, + fill_pending: false, + doc_size: [1000, 800], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + }; assert!(clamp_view(&mut v, vec2(500.0, 400.0), 1.0)); assert_eq!(v.center, [250.0, 200.0]); assert!(!clamp_view(&mut v, vec2(500.0, 400.0), 1.0), "stable: no repaint loop"); @@ -308,7 +319,18 @@ mod tests { let (at, len) = s.thumb((0.0, 1000.0), 0.0); assert!(at.is_finite() && len.is_finite()); assert_eq!(s.doc_per_point((0.0, 1000.0), 0.0), 0.0); - let mut v = View { zoom: 1.0, center: [0.0, 0.0], fit_pending: false, fill_pending: false, doc_size: [0, 0], rotation: 0.0 }; + let mut v = View { + zoom: 1.0, + center: [0.0, 0.0], + fit_pending: false, + fill_pending: false, + doc_size: [0, 0], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + }; assert!(!clamp_view(&mut v, vec2(500.0, 400.0), 1.0)); } diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs index 52d44b9b2b..21affeadfd 100644 --- a/crates/ui-egui/src/state.rs +++ b/crates/ui-egui/src/state.rs @@ -479,11 +479,40 @@ pub struct View { /// Canvas camera rotation in degrees, wrapped to (−180, 180]. Turns the view, not the pixels. #[serde(default)] pub rotation: f32, + /// Transient presentation state for a discrete zoom command; the target camera above remains + /// authoritative and this flag is never persisted. + #[serde(skip)] + pub(crate) zoom_animating: bool, + /// Optional document/screen anchor for a pointer-centred Zoom-tool transition. + #[serde(skip)] + pub(crate) zoom_anchor: Option<([f64; 2], [f32; 2])>, + #[serde(skip)] + pub(crate) display_camera: Option<(f32, [f32; 2])>, + #[serde(skip)] + pub(crate) zoom_transition: Option, +} + +#[derive(Clone, Copy, Debug, PartialEq)] +pub(crate) struct ZoomTransition { + pub from: (f32, [f32; 2]), + pub target: (f32, [f32; 2]), + pub started: f64, } impl Default for View { fn default() -> Self { - Self { zoom: 1.0, center: [0.0, 0.0], fit_pending: true, fill_pending: false, doc_size: [0, 0], rotation: 0.0 } + Self { + zoom: 1.0, + center: [0.0, 0.0], + fit_pending: true, + fill_pending: false, + doc_size: [0, 0], + rotation: 0.0, + zoom_animating: false, + zoom_anchor: None, + display_camera: None, + zoom_transition: None, + } } } diff --git a/crates/ui-egui/src/view_cmds.rs b/crates/ui-egui/src/view_cmds.rs index 190634cca9..cddc47ec94 100644 --- a/crates/ui-egui/src/view_cmds.rs +++ b/crates/ui-egui/src/view_cmds.rs @@ -607,6 +607,8 @@ fn run(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, p: &Value) -> Res let screen = app.session.prefs().units_and_rulers.screen_resolution.max(1.0) as f32; let z = if id == "view.twoHundredPercent" { 2.0 } else { screen / dpi }; app.ui.views[i].zoom = crate::zoom_levels::clamp(z, size); + app.ui.views[i].zoom_animating = true; + app.ui.views[i].zoom_anchor = None; Ok(json!({"zoom": app.ui.views[i].zoom})) } "view.fitLayersOnScreen" => fit_layers(app), @@ -638,12 +640,18 @@ fn fit_layers(app: &mut PhotocraftApp) -> Result { v.zoom = crate::zoom_levels::clamp(points * ppp, size); v.center = [(b.x0 + b.x1) as f32 / 2.0, (b.y0 + b.y1) as f32 / 2.0]; v.fit_pending = false; + v.zoom_animating = true; + v.zoom_anchor = None; Ok(json!({"zoom": v.zoom, "bounds": [b.x0, b.y0, b.x1, b.y1]})) } pub(crate) fn float_window(app: &mut PhotocraftApp, doc: usize, offset: usize) -> u64 { let wid = app.ui.alloc_id(); let mut view = app.ui.views.get(doc).cloned().unwrap_or_default(); + view.zoom_animating = false; + view.zoom_anchor = None; + view.zoom_transition = None; + view.display_camera = None; view.fit_pending = offset > 0 || view.fit_pending; app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true }); wid @@ -679,6 +687,8 @@ fn arrange(app: &mut PhotocraftApp, k: &str) -> Result { let apply = |v: &mut crate::state::View| { if zoom { v.zoom = src.zoom; + v.zoom_animating = true; + v.zoom_anchor = None; } if loc { v.center = src.center; diff --git a/crates/ui-egui/src/zoom_tool.rs b/crates/ui-egui/src/zoom_tool.rs index e28e7e9c0a..c892041e76 100644 --- a/crates/ui-egui/src/zoom_tool.rs +++ b/crates/ui-egui/src/zoom_tool.rs @@ -42,6 +42,8 @@ pub fn scrub_zoom(zoom0: f32, dx: f32, size: [u32; 2]) -> f32 { /// Set `view` to `zoom` (device pixels per document pixel) with document point `doc` shown at /// screen point `screen` (egui points) on a display with `ppp` physical pixels per point. pub fn anchor_view(view: &mut View, xf: &ViewXform, screen: Pos2, doc: [f64; 2], zoom: f32, ppp: f32) { + view.zoom_animating = false; + view.zoom_anchor = None; view.zoom = zoom; let ppp = if ppp.is_finite() && ppp > 0.0 { ppp } else { 1.0 }; let d = xf.unmap_vec((screen - xf.rect.center()) / (zoom / ppp)); @@ -194,6 +196,154 @@ mod tests { assert_eq!(h.state().current_zoom(), crate::zoom_levels::step(zc, 1, h.state().ui.views[0].doc_size)); } + #[test] + fn discrete_zoom_animates_and_keeps_its_document_anchor_fixed() { + let mut h = harness(true, 1.0); + let r = h.state().last_canvas_rect; + let pointer = r.center() + vec2(90.0, -45.0); + let anchor_doc = view_xf(&h).to_doc(pointer); + let anchor_screen = if h.state().session.prefs().tools.zoom_clicked_point_to_center { r.center() } else { pointer }; + let start = h.state().current_zoom(); + + h.event(Event::PointerMoved(pointer)); + h.step(); + press(&mut h, pointer, true); + press(&mut h, pointer, false); + + let target = crate::zoom_levels::step(start, 1, h.state().ui.views[0].doc_size); + assert_eq!(h.state().current_zoom(), target, "the model keeps the requested zoom as its target"); + assert!(h.state().ui.views[0].zoom_animating); + let mut time = h.ctx.input(|i| i.time) + 0.05; + for _ in 0..5 { + time += 0.01; + h.input_mut().time = Some(time); + h.step(); + } + let displayed_xf = view_xf(&h); + let displayed = displayed_xf.to_screen(anchor_doc[0] as f32, anchor_doc[1] as f32); + assert!(displayed.distance(anchor_screen) < 0.5, "anchor moved to {displayed:?}"); + let intermediate = displayed_xf.zoom; + assert!(intermediate > start && intermediate < target, "expected an intermediate zoom, got {intermediate}"); + + for _ in 0..30 { + time += 0.01; + h.input_mut().time = Some(time); + h.step(); + } + assert!(!h.state().ui.views[0].zoom_animating); + assert_eq!(view_xf(&h).zoom, target); + assert_eq!(h.state().current_zoom(), target); + } + + #[test] + fn gpu_zoom_animation_reuses_the_document_composite() { + let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else { + eprintln!("skipping: no GPU adapter"); + return; + }; + let renderer = egui_kittest::wgpu::WgpuTestRenderer::from_render_state(rs); + let mut h = Harness::builder().with_size(vec2(1000.0, 700.0)).with_pixels_per_point(1.0).renderer(renderer).build_eframe(|cc| { + PhotocraftApp::setup_context(&cc.egui_ctx, crate::theme::ThemeKind::ALL[0]); + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.set_wgpu(cc.wgpu_render_state.clone().unwrap()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("edit.fill", json!({"color": "#2060c0"})).unwrap(); + app + }); + h.run_steps(4); + h.state_mut().run("view.actualPixels", json!({})).unwrap(); + h.step(); + let time = h.ctx.input(|i| i.time) + 0.3; + h.input_mut().time = Some(time); + h.step(); + let id = h.state().session.documents()[0].doc.id; + assert!(h.state().canvases[&(id, crate::canvas::GPU_OUTPUT)].on_gpu); + let directory = std::env::var_os("CRAFT_UI_ZOOM_FIXTURES").map(std::path::PathBuf::from); + if let Some(directory) = &directory { + std::fs::create_dir_all(directory).unwrap(); + } + h.state_mut().run("view.zoomIn", json!({})).unwrap(); + let target = h.state().current_zoom(); + for (name, elapsed) in [("start", 0.0), ("midpoint", 0.11), ("finished", 0.23)] { + h.state_mut().perf.last_refresh = ""; + h.input_mut().time = Some(time + elapsed); + h.step(); + assert!(h.state().perf.gpu, "{name}: keep the GPU canvas"); + assert_eq!(h.state().perf.last_refresh, "", "{name}: reuse the composite"); + assert!(h.state().canvases.values().all(|cache| cache.texture.is_none()), "{name}: no CPU texture fallback"); + let xf = view_xf(&h); + if name == "midpoint" { + assert!(xf.zoom > 1.0 && xf.zoom < target); + } + let image = h.render().unwrap(); + let center = xf.to_screen(200.0, 150.0); + let pixel = image.get_pixel(center.x as u32, center.y as u32); + assert!(pixel[2] > pixel[0] * 2, "{name}: document remains visible: {pixel:?}"); + if let Some(directory) = &directory { + image.save(directory.join(format!("photocraft-zoom-{name}.png"))).unwrap(); + } + } + assert!(!h.state().ui.views[0].zoom_animating); + assert_eq!(view_xf(&h).zoom, target); + } + + #[test] + fn view_commands_retarget_a_zoom_click_without_retaining_its_anchor() { + for command in ["view.zoomIn", "view.actualPixels", "view.fitOnScreen"] { + let mut h = harness(true, 1.0); + let pointer = h.state().last_canvas_rect.center() + vec2(90.0, -45.0); + h.event(Event::PointerMoved(pointer)); + h.step(); + press(&mut h, pointer, true); + press(&mut h, pointer, false); + assert!(h.state().ui.views[0].zoom_anchor.is_some()); + h.step(); + h.state_mut().run(command, json!({})).unwrap(); + assert!(h.state().ui.views[0].zoom_anchor.is_none(), "{command}"); + h.step(); + let time = h.ctx.input(|i| i.time) + 0.3; + h.input_mut().time = Some(time); + h.step(); + let target = &h.state().ui.views[0]; + assert!(!target.zoom_animating, "{command}"); + assert_eq!(view_xf(&h).zoom, target.zoom); + assert_eq!(view_xf(&h).center, target.center); + } + } + + #[test] + fn wheel_pinch_pan_and_scrubby_zoom_interrupt_a_transition() { + for gesture in 0..5 { + let mut h = harness(true, 1.0); + let pointer = h.state().last_canvas_rect.center(); + h.event(Event::PointerMoved(pointer)); + h.step(); + h.state_mut().run("view.zoomIn", json!({})).unwrap(); + h.step(); + assert!(h.state().ui.views[0].zoom_animating); + match gesture { + 0 => h.event(Event::Zoom(1.25)), + 1 | 2 => h.event(Event::MouseWheel { + unit: egui::MouseWheelUnit::Line, + delta: vec2(0.0, 1.0), + phase: egui::TouchPhase::Move, + modifiers: egui::Modifiers { alt: gesture == 1, ..Default::default() }, + }), + _ => { + h.state_mut().ui.tool = if gesture == 3 { crate::state::Tool::Hand } else { crate::state::Tool::Zoom }; + press(&mut h, pointer, true); + h.event(Event::PointerMoved(pointer + vec2(120.0, 0.0))); + } + } + h.step(); + assert!(!h.state().ui.views[0].zoom_animating, "gesture {gesture}"); + h.step(); + let target = &h.state().ui.views[0]; + assert_eq!(view_xf(&h).zoom, target.zoom, "gesture {gesture}"); + assert_eq!(view_xf(&h).center, target.center, "gesture {gesture}"); + } + } + #[test] fn zoom_drags_keep_the_press_point_in_rotated_and_flipped_views() { for (scrubby, out, rotation, flip, ppp) in [ diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 71f7897434..77ea389caf 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity: tools, handles, modifiers and feel -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Hand-tool flick panning) · **Target:** Adobe Photoshop 2026 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Hand-tool flick panning and animated zoom) · **Target:** Adobe Photoshop 2026 How PhotoCraft's direct manipulation compares with Photoshop 2026 (27.11.0): the toolbox, the handles and modifier keys of each gesture, nudging, snapping, numeric precision, navigation, @@ -163,7 +163,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme | Hold any tool letter for a temporary tool | missing | #2672 | | Scrubby zoom | done | `zoom_tool.rs` | | Flick panning | done | `flick_pan.rs` (Preferences › Tools › Enable Flick Panning) | -| Animated zoom | missing | unread pref; #566 | +| Animated zoom | done | `canvas.rs`, `zoom_tool.rs`; #566; discrete Zoom clicks and View zoom controls ease over 220 ms by default, with anchored transitions and immediate direct navigation; the existing preference remains hidden | | Double-click Zoom tool = 100%, double-click Hand = fit | partial | Zoom missing (#2508) | | ⌥-wheel zoom in gentle steps | missing | UI-217-18 | | Wheel, smooth scrolling and pinch as in Photoshop | partial | #2485, #2463, #1989 | @@ -210,3 +210,4 @@ Paragraph; the rest open as in-app floating windows. | 2026-10-10 | major | First version, from a source audit against Photoshop 2026 27.11.0's shortcuts file and the open issues | | 2026-10-10 | minor | Fixed Crop live resize snapping feedback and outdated-camera rendering, applied ratios immediately to centred inscribed previews, and removed two-point options-bar overflow; added pointer, rendering, dropdown/Enter, Swap/X and scrolling regressions | | 2026-10-11 | minor | Flick panning done: releasing a moving Hand drag (tool, Space or middle button) glides and decays, gated by Enable Flick Panning | +| 2026-10-11 | minor | Animated zoom done: 220 ms transitions per view for discrete Zoom clicks and View controls; GPU composites are reused, coordinates follow the displayed camera, and direct navigation interrupts immediately |