LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
refactor(ui-egui): split the detail view, mask overlay and denoise panel
Dylan M. Taylorf858578f8c01
diff --git a/crates/ui-egui/src/panels/denoise.rs b/crates/ui-egui/src/panels/denoise.rsindex fdb208b51..b72df10b2 100644--- a/crates/ui-egui/src/panels/denoise.rs+++ b/crates/ui-egui/src/panels/denoise.rs@@ -319,6 +319,13 @@ fn work_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &Vif status["enabled"] != true {return;}+ speed_section(app, ui, t, list, &status);+ photos_section(app, ui, t, list, &status);+ cache_section(app, ui, t, list, &status);+}++/// Where the work runs.+fn speed_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &Value, status: &Value) {heading(ui, t, "Speed");let current = list["runOn"].as_str().unwrap_or("auto").to_string();let mut run_on = current.as_str();@@ -342,6 +349,10 @@ fn work_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &Vapp.caches.denoise.epoch += 1;}}+}++/// Whether photos are made as they are looked at, and the progress of what is being made.+fn photos_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &Value, status: &Value) {heading(ui, t, "Photos");let mut auto = list["auto"].as_bool().unwrap_or(true);if check(ui, "settings.denoiseAuto", &mut auto, "Make the denoised picture of the photos I am looking at") {@@ -350,27 +361,7 @@ fn work_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &V}hint(ui, t, "Only photos whose AI Denoise amount is above 0 are made. Exports always make theirs if it is missing.");let (running, queued) = (app.caches.denoise.running, app.caches.denoise.queued);- match running {- Some((done, total)) => {- let name = status["running"]["photo"]- .as_u64()- .and_then(|p| app.session.catalog.photo(PhotoId(p)).map(|p| p.file_name.clone()))- .unwrap_or_default();- let text = tr_format!(- "Denoising {name}: {done} of {total} tiles{}",- if queued > 0 { tr_format!(" · {queued} waiting", queued = queued) } else { String::new() },- name = name,- done = done,- total = total- );- settings_bar(ui, done, total, text);- }- None if queued > 0 => hint(ui, t, &count(queued, "photo waiting", "photos waiting")),- None => {- let ready = status["ready"].as_u64().unwrap_or(0);- hint(ui, t, &count(ready, "photo has its denoised picture.", "photos have their denoised picture."))- }- }+ progress_line(app, ui, t, status, running, queued);ui.horizontal(|ui| {let r = ui.button(tr("Denoise all photos with an Amount"));register(ui, "denoise:queueAll", r.rect);@@ -385,6 +376,37 @@ fn work_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &V}}});+}++/// "Denoising {photo}: {done} of {total} tiles", and how many photos wait.+fn running_text(app: &LightcraftApp, status: &Value, done: u64, total: u64, queued: u64) -> String {+ let name =+ status["running"]["photo"].as_u64().and_then(|p| app.session.catalog.photo(PhotoId(p)).map(|p| p.file_name.clone())).unwrap_or_default();+ tr_format!("Denoising {name}: {done} of {total} tiles{}", waiting_suffix(queued), name = name, done = done, total = total)+}++/// " · N waiting" after the running photo, when any wait.+fn waiting_suffix(queued: u64) -> String {+ if queued > 0 { tr_format!(" · {queued} waiting", queued = queued) } else { String::new() }+}++/// What is being made now, or how many photos wait or are done.+fn progress_line(app: &LightcraftApp, ui: &mut egui::Ui, t: &Tokens, status: &Value, running: Option<(u64, u64)>, queued: u64) {+ match running {+ Some((done, total)) => {+ let text = running_text(app, status, done, total, queued);+ settings_bar(ui, done, total, text);+ }+ None if queued > 0 => hint(ui, t, &count(queued, "photo waiting", "photos waiting")),+ None => {+ let ready = status["ready"].as_u64().unwrap_or(0);+ hint(ui, t, &count(ready, "photo has its denoised picture.", "photos have their denoised picture."))+ }+ }+}++/// The cache's contents and limit.+fn cache_section(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, list: &Value, status: &Value) {heading(ui, t, "Cache");let (files, bytes) = (status["cache"]["files"].as_u64().unwrap_or(0), status["cache"]["bytes"].as_u64().unwrap_or(0));hint(diff --git a/crates/ui-egui/src/panels/detail.rs b/crates/ui-egui/src/panels/detail.rsindex 3eb94779c..2b58595d2 100644--- a/crates/ui-egui/src/panels/detail.rs+++ b/crates/ui-egui/src/panels/detail.rs@@ -138,11 +138,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {filmstrip(app, ui, Rect::from_min_max(pos2(full.left(), canvas.bottom()), full.max));}let Some(id) = app.session.active() else {- if super::empty_library::shown(&app.session) {- super::empty_library::show(app, ui, canvas);- } else {- super::empty_message(ui, canvas, "No photo selected", "Choose a photo in the grid or filmstrip");- }+ show_no_photo(app, ui, canvas);return;};let Some(photo) = app.session.catalog.photo(id).cloned() else { return };@@ -154,47 +150,15 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {let frame = Frame::with_lens(photo.width.max(1) as usize, photo.height.max(1) as usize, &d, !crop_tool, photo.embedded_lens.as_ref());let aspect = frame.aspect() as f32;let ppp = ui.ctx().pixels_per_point();- let area = canvas.shrink(if fullscreen {- 0.0- } else if crop_tool {- 48.0- } else {- 24.0- });+ let area = canvas.shrink(loupe_margin(fullscreen, crop_tool));let native = output_px(&frame);let texture_side = texture_side(ui.ctx());// two views (before, after): side by side or stackedlet split = matches!(app.ui.before_after, BeforeAfter::SideBySide | BeforeAfter::TopBottom);let split_view = matches!(app.ui.before_after, BeforeAfter::Split | BeforeAfter::SplitTopBottom);- let areas: Vec<Rect> = match app.ui.before_after {- BeforeAfter::SideBySide => {- let half = area.width() / 2.0 - 6.0;- vec![- Rect::from_min_size(area.min, vec2(half, area.height())),- Rect::from_min_size(pos2(area.center().x + 6.0, area.top()), vec2(half, area.height())),- ]- }- BeforeAfter::TopBottom => {- let half = area.height() / 2.0 - 14.0;- vec![- Rect::from_min_size(area.min, vec2(area.width(), half)),- Rect::from_min_size(pos2(area.left(), area.center().y + 14.0), vec2(area.width(), half)),- ]- }- _ => vec![area],- };+ let areas = view_areas(app.ui.before_after, area);let main_area = *areas.last().unwrap_or(&area);- // A previous crop/rotation can stay visible while its replacement renders. Its pixels- // must not override the current frame geometry, even when it is the same photo.- let current_texture = |t: &&crate::render::Tex| t.photo == id && t.look == Some((crate::render::geometry_look(&d), !crop_tool));- let visible_texture_aspect = app- .renderer- .textures- .get(&Slot::Main)- .filter(current_texture)- .or_else(|| app.renderer.textures.get(&Slot::Preview).filter(current_texture))- .or_else(|| app.renderer.thumb(id).filter(current_texture))- .map(|tex| tex.size[0].max(1) as f32 / tex.size[1].max(1) as f32);+ let visible_texture_aspect = visible_texture_aspect(app, id, &d, crop_tool);// Follow the texture only where it really differs (an unsupported raw's embedded JPEG with// another crop): a texture's whole-pixel size is a little off the exact aspect, and the crop// tool's overlays need the frame's own geometry.@@ -204,15 +168,13 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {let mut target_rect = fit_rect(main_area, display_aspect, app.ui.zoom, native, ppp, app.ui.pan);let mut img_rect = animated_rect(ui.ctx(), &mut app.ui.zoom_anim, target_rect);let in_pane = |pane: Rect, image: Rect| image.translate(pane.center() - main_area.center());- let mut navigating = false;- for &view_area in &areas {+ let navigating = areas.iter().any(|&view_area| {let view_img = in_pane(view_area, img_rect);- if navigate_gesture(app, ui, &resp, view_area, view_img, native) || middle_pan(app, ui, &resp, view_area, view_img) {- navigating = true;- target_rect = fit_rect(main_area, display_aspect, app.ui.zoom, native, ppp, app.ui.pan);- img_rect = target_rect;- break;- }+ navigate_gesture(app, ui, &resp, view_area, view_img, native) || middle_pan(app, ui, &resp, view_area, view_img)+ });+ if navigating {+ target_rect = fit_rect(main_area, display_aspect, app.ui.zoom, native, ppp, app.ui.pan);+ img_rect = target_rect;}let before_img = in_pane(areas[0], img_rect);let before_target = in_pane(areas[0], target_rect);@@ -222,14 +184,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {let overlay = view_overlay(app, &d);// a drag drafts at full size where the GPU draws the view (by the GPU's own rule, `handles`;// `ready` first: `available` would wait for a device still being created)- let gpu = interacting- && lightcraft_engine::gpu::handles(- lightcraft_pipeline::OutputDepth::U8,- app.ui.soft_proof && lightcraft_pipeline::proof_profile(app.ui.proof.profile).is_some(),- overlay,- )- && lightcraft_engine::gpu::ready()- && lightcraft_engine::gpu::available();+ let gpu = interacting && gpu_draws_view(app, overlay);let shown = app.renderer.textures.get(&Slot::Main).filter(|t| t.photo == id && t.quick.is_none()).map(|t| (t.key, t.ms));let drag = app.session.interaction.as_ref().map(|i| (i.photo, i.label.as_str()));let now = ui.input(|i| i.time);@@ -250,10 +205,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {draft,windows: overlay_supports_window(overlay),};- let mut plan = crate::region::plan(&app.ui.settings, sizes);- if plan.window_edge.is_some_and(|edge| app.window_refused == Some((id, look, edge))) {- plan = crate::region::plan(&app.ui.settings, crate::region::ViewSizes { windows: false, ..sizes });- }+ let plan = loupe_plan(app, id, look, sizes);// time the full-size drafts where they are what shows: under a window the whole-frame draft// is small anyway, and the frame's time is the window's uploadif let Some((key, ms)) = shown.filter(|_| plan.window_edge.is_none()) {@@ -271,14 +223,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {// copied 1:1 (no resample in the pipeline, whose prefilter and bilinear pass soften detail near// the output's limit) and shrunk once, by the Lanczos display fit below.// (zoomed in under a window render, the whole frame is hidden: it stays canvas-sized)- let want = if interacting || plan.window_edge.is_some() {- plan.main_edge- } else {- // (a user's explicit Preview size below the preview level still caps it)- let limit = if app.ui.settings.preview_limit == 0 { usize::MAX } else { app.ui.settings.preview_limit as usize };- let floor = lightcraft_engine::SourceLevel::Preview.max_edge().min(limit).min(native_long);- plan.main_edge.max(floor).min(texture_side.max(crate::state::MIN_TEXTURE_SIDE))- };+ let want = whole_frame_edge(app, interacting, &plan, native_long, texture_side);// The short side is rounded, not truncated: a truncated box (2560 x 1706 for a 2560 x 1707// source) made the render a slightly anisotropic resample of its source, a 2-tap blur along// one axis only. A box that matches the source to rounding is rendered at exactly its size.@@ -287,72 +232,19 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {// hover and before renders are stand-ins: the preview size is plenty and keeps them cheaplet se = app.ui.settings.stand_in_edge(want, texture_side);let (sw, sh) = if aspect >= 1.0 { (se, short(se, aspect)) } else { (short(se, 1.0 / aspect), se) };- if let Some(job) = app.session.loupe_job(id, rw.max(8), rh.max(8), !crop_tool) {- let job = if interacting { job.draft() } else { job };- // at rest the render is shrunk to exactly the size it is drawn at with a Lanczos filter on- // the worker, so the window draws it texel for texel instead of shrinking it with 2-tap- // sampling (the render is up to a 64 px step larger, or the preview level)- let job = if interacting { job } else { job.with_display_fit(fit_px[0], fit_px[1]) };- let job = job.with_overlay(overlay).with_proof(app.ui.soft_proof.then_some(app.ui.proof));- let job = job.with_hidden_grading(app.ui.grading_hidden_for(id));- app.renderer.request(Slot::Main, job, 100);- // a drag's draft that renders in a few ms (GPU) is drawn in this frame, not the next (zoomed- // in, what changes on screen is the window's draft)- #[cfg(not(target_arch = "wasm32"))]- if interacting && plan.window_edge.is_none() {- let frame = ui.input(|i| i.predicted_dt).clamp(1.0 / 240.0, 1.0 / 30.0);- // (a frame time that is not a number waits for nothing)- let budget = std::time::Duration::try_from_secs_f32(frame * 0.4).unwrap_or_default();- app.renderer.wait_for_draft(ui.ctx(), &mut app.session, budget);- }- }+ let ask = LoupeAsk { id, with_crop: !crop_tool, interacting, fit_px, overlay };+ request_main(app, ui, &ask, [rw, rh], plan.window_edge.is_none());// hovering a preset or profile: the photo with that look, shown instead of the loupe render// once it is ready (nothing is committed)- let hover_key = match app.hover_preview.clone() {- Some(h) if !interacting => app.session.preview_job(id, sw.max(8), sh.max(8), !crop_tool, &h.settings).map(|job| {- // (the same display fit as the After view, drawn texel for texel like it)- let job = job.with_display_fit(fit_px[0], fit_px[1]);- let key = job.key;- app.renderer.request(Slot::Hover, job, 105);- (key, h.label)- }),- _ => None,- };- // once this photo is on screen: prepare its neighbours in filmstrip order (source decoded and- // kept, view render cached) so stepping to them is instant- if !interacting && !app.renderer.is_pending(Slot::Main) && app.renderer.textures.get(&Slot::Main).is_some_and(|t| t.photo == id) {- let ids = app.session.visible_cloned();- if let Some(i) = ids.iter().position(|p| *p == id) {- let next = ids.get(i + 1).copied();- let prev = i.checked_sub(1).and_then(|j| ids.get(j)).copied();- for (n, nid) in [next, prev].into_iter().enumerate() {- let Some(nid) = nid else { continue };- let Some(np) = app.session.catalog.photo(nid).cloned() else { continue };- let nf = Frame::with_lens(np.width.max(1) as usize, np.height.max(1) as usize, &np.develop, !crop_tool, np.embedded_lens.as_ref());- let na = nf.aspect() as f32;- let nr = fit_rect(main_area, na, app.ui.zoom, output_px(&nf), ppp, app.ui.pan);- let nw =- app.ui.settings.prefetch_edge(nr.width().max(nr.height()) * ppp, output_px(&nf).into_iter().max().unwrap_or(1), texture_side);- let (w, h) = if na >= 1.0 { (nw, (nw as f32 / na) as usize) } else { ((nw as f32 * na) as usize, nw) };- if let Some(job) = app.session.loupe_job(nid, w.max(8), h.max(8), !crop_tool) {- app.renderer.prefetch(Slot::Prefetch(n as u8), job, PREFETCH_PRIORITY);- }- }- }+ let hover_key = request_hover(app, &ask, [sw, sh]);+ if !interacting {+ prefetch_neighbours(app, id, main_area, ppp, texture_side, !crop_tool);}// until the loupe has this photo: show its cached render / embedded preview / a thumbnail- if app.renderer.textures.get(&Slot::Main).is_none_or(|t| t.photo != id)- && let Some(q) = app.session.quick_view_job(id, want.max(8), !crop_tool)- {- app.renderer.request_quick(Slot::Preview, q, 110);- }+ request_stand_in(app, id, want, !crop_tool);let show_before = app.ui.before_after == BeforeAfter::Original || ui.input(|i| i.key_down(egui::Key::Backslash));- if (split || show_before || split_view)- && let Some(job) = app.session.render_job(id, sw.max(8), sh.max(8), true, !crop_tool)- {- // (the same display fit as the After view, so both panes are the same texture size)- let job = if interacting { job } else { job.with_display_fit(fit_px[0], fit_px[1]) };- app.renderer.request(Slot::Before, job, 90);+ if split || show_before || split_view {+ request_before(app, &ask, [sw, sh]);}// zoomed past what the whole-frame render holds: also render the part on screen, at no more// than 100 % (the GPU magnifies beyond that), for each side that is shown. Mask overlays and@@ -371,63 +263,18 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {look,holding: navigating || app.size_hold.holding(now),};- // (slot, before side?, rect to draw in, rect it is requested for, area whose pixels show)- let mut window_views: Vec<WindowView> = Vec::new();- if window_ctx.frame_edge.is_some() {- let after = WindowView { slot: Slot::Region, before: false, img: img_rect, target: target_rect, visible: main_area };- if split {- window_views.push(WindowView { slot: Slot::RegionBefore, before: true, img: before_img, target: before_target, visible: areas[0] });- window_views.push(after);- } else if show_before {- window_views.push(WindowView { slot: Slot::RegionBefore, before: true, img: img_rect, target: target_rect, visible: canvas });- } else if split_view {- window_views.push(WindowView { slot: Slot::RegionBefore, before: true, img: img_rect, target: target_rect, visible: canvas });- window_views.push(WindowView { visible: canvas, ..after });- } else {- window_views.push(WindowView { visible: canvas, ..after });- }- }- let mut windows: Vec<(WindowView, crate::region::RegionView)> = Vec::new();- for v in window_views {- if let Some(view) = request_window(app, &window_ctx, &v) {- windows.push((v, view));- }- }- for (slot, before) in [(Slot::Region, false), (Slot::RegionBefore, true)] {- let shown = windows.iter().find(|(v, _)| v.before == before).map(|(_, view)| *view);- if before {- app.region_before_view = shown;- } else {- app.region_view = shown;- }- if shown.is_none() {- app.region_tiles.retain(|(b, _), _| *b != before);- app.renderer.release(slot);- }- }- let p = ui.painter_at(canvas);- // what a view slot shows: its own render of this photo, else the stand-ins (no blank frame- // between photos, and the full render replaces them in place)- let draw = |slot: Slot, r: Rect, clip: Rect| -> &'static str {- let mine = |s: Slot| app.renderer.textures.get(&s).filter(|t| t.photo == id);- let (tex, what) = if let Some(t) = mine(slot) {- (t, "render")- } else if let Some(t) = mine(Slot::Preview) {- (t, t.quick.map(quick_name).unwrap_or("preview"))- } else if let Some(t) = app.renderer.thumb(id) {- (t, "thumb")- } else {- return "none";- };- let image_rect = snap_fit_rect(fit_texture_rect(r, tex.size), tex.size, ppp);- p.with_clip_rect(clip).image(tex.tex.id(), image_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);- what+ let window_views = if window_ctx.frame_edge.is_some() {+ let mode = ViewMode { split, show_before, split_view };+ window_views(mode, &Views { img_rect, target_rect, before_img, before_target, areas: &areas, main_area, canvas })+ } else {+ Vec::new()};+ let windows = request_windows(app, &window_ctx, window_views);+ let p = ui.painter_at(canvas);+ let draw = |slot: Slot, r: Rect, clip: Rect| draw_slot(app, &p, id, ppp, slot, r, clip);// soft proofing: a paper-white surround and the proof's name, as Lightroom shows itif app.ui.soft_proof && !fullscreen {- p.rect_filled(canvas, 0.0, Color32::from_gray(238));- let label = crate::i18n::tr_format!("Proof Preview · {}", app.ui.proof.space.label());- p.text(pos2(canvas.right() - 16.0, canvas.top() + 14.0), Align2::RIGHT_CENTER, label, t.font(12.5), Color32::from_gray(60));+ proof_surround(app, &p, &t, canvas);}let shown;// the Before label's pill, painted once the window renders are down (they would cover it)@@ -441,10 +288,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {let br = before_img;draw(Slot::Before, br, areas[0]);shown = draw(Slot::Main, img_rect, main_area);- // the labels under each photo, or under its pane when the photo reaches past it- let label_at = |r: Rect, pane: Rect| pos2(r.left().max(pane.left()), r.bottom().min(pane.bottom()) + 14.0);- p.text(label_at(br, areas[0]), Align2::LEFT_CENTER, crate::i18n::tr("Before"), t.font(12.0), t.text_dim);- p.text(label_at(img_rect, main_area), Align2::LEFT_CENTER, crate::i18n::tr("After"), t.font(12.0), t.text_dim);+ split_labels(&p, &t, [(br, areas[0]), (img_rect, main_area)]);} else if show_before {shown = draw(Slot::Before, img_rect, canvas);// on the photo itself, so it gets the hover label's dark pill to stay readable over light@@ -454,53 +298,17 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {} else if let Some((_key, label)) = &hover_key&& let Some(tex) = app.renderer.textures.get(&Slot::Hover).filter(|t| t.photo == id){- let hover_rect = fit_texture_rect(img_rect, tex.size);- p.image(tex.tex.id(), hover_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);- let g = p.layout_no_wrap(label.clone(), t.font(12.0), Color32::WHITE);- let bg = label_badge_rect(hover_rect, canvas, g.size(), badge_top_inset);- p.rect_filled(bg, 4.0, Color32::from_black_alpha(160));- p.galley(bg.min + vec2(8.0, 4.0), g, Color32::WHITE);+ draw_hover(&p, &t, tex, label, [img_rect, canvas], badge_top_inset);shown = "hover";} else {shown = draw(Slot::Main, img_rect, canvas);if shown == "none" {- match app.renderer.failure_of(Slot::Main, id) {- Some(e) => {- p.text(- canvas.center() - vec2(0.0, 10.0),- Align2::CENTER_CENTER,- crate::i18n::tr("This photo can't be opened"),- t.semibold(14.0),- t.text,- );- p.text(canvas.center() + vec2(0.0, 12.0), Align2::CENTER_CENTER, e, t.font(12.0), t.text_dim);- }- None if app.ui.settings.loupe_messages => {- p.text(canvas.center(), Align2::CENTER_CENTER, crate::i18n::tr("Rendering…"), t.font(13.0), t.text_dim);- }- None => {}- }+ none_message(app, &p, &t, canvas, id);}}app.loupe_shown = Some((id, shown));- // a wipe shows the Before whole-frame render on its side of the line…let line = crate::region::wipe_line(img_rect, canvas);- if app.ui.before_after == BeforeAfter::Split- && let Some(tex) = app.renderer.textures.get(&Slot::Before).filter(|t| t.photo == id)- {- let before_rect = fit_texture_rect(img_rect, tex.size);- let u = ((line.x - before_rect.left()) / before_rect.width().max(1.0)).clamp(0.0, 1.0);- let left = Rect::from_min_max(before_rect.min, pos2(before_rect.left() + u * before_rect.width(), before_rect.bottom()));- p.image(tex.tex.id(), left, Rect::from_min_max(pos2(0.0, 0.0), pos2(u, 1.0)), Color32::WHITE);- }- if app.ui.before_after == BeforeAfter::SplitTopBottom- && let Some(tex) = app.renderer.textures.get(&Slot::Before).filter(|t| t.photo == id)- {- let before_rect = fit_texture_rect(img_rect, tex.size);- let v = ((line.y - before_rect.top()) / before_rect.height().max(1.0)).clamp(0.0, 1.0);- let top = Rect::from_min_max(before_rect.min, pos2(before_rect.right(), before_rect.top() + v * before_rect.height()));- p.image(tex.tex.id(), top, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, v)), Color32::WHITE);- }+ draw_wipe_before(app, &p, id, img_rect, line);// …and the window renders go over the whole-frame ones, all of them, where they belong in the// frame (clipped to their pane, or their side of the line)for (v, view) in &windows {@@ -510,138 +318,47 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {draw_window(&p.with_clip_rect(clip), app, &window_ctx, v, view);}if let Some((bg, g)) = before_badge {- p.rect_filled(bg, 4.0, Color32::from_black_alpha(160));- p.galley(bg.min + vec2(8.0, 4.0), g, Color32::WHITE);+ paint_badge(&p, bg, g);register(ui, "canvas:beforeLabel", bg);}// the line of a wipe over both- if app.ui.before_after == BeforeAfter::Split {- p.line_segment([pos2(line.x, img_rect.top()), pos2(line.x, img_rect.bottom())], Stroke::new(1.5, Color32::WHITE));- }- if app.ui.before_after == BeforeAfter::SplitTopBottom {- p.line_segment([pos2(img_rect.left(), line.y), pos2(img_rect.right(), line.y)], Stroke::new(1.5, Color32::WHITE));- }- if app.ui.show_clipping && !show_before && !fullscreen {- clipping_overlay(app, &p, img_rect);- }- // View ▸ Loupe Overlay ▸ Layout Image, over the photo (the After view in a before/after)- super::layout_overlay::draw(app, &p, img_rect);- register(ui, "canvas:image", img_rect);+ draw_wipe_line(app.ui.before_after, &p, img_rect, line);let map = CanvasMap::new(&frame, img_rect);- info_overlay(app, &p, canvas, &photo);- if !fullscreen {- filter_pill(app, ui, canvas);- }- if app.ui.face_boxes {- // a name box left open on another photo is dropped- if app.ui.name_edit.as_ref().is_some_and(|e| e.photo != id.0) {- app.ui.name_edit = None;- }- let hints = super::faces::hints_for(app, id.0);- let people = if app.ui.name_edit.is_some() { app.caches.person_names(&app.session.catalog) } else { Default::default() };- // while the name box is open and recognition is not set up, the box offers the next step- let setup = if app.ui.name_edit.is_some() { super::faces::setup(app, ui.ctx()) } else { super::faces::Setup::Running };- let regions = RegionContext { photo: &photo, orient: d.orientation, hints: hints.as_deref(), people: &people, setup };- match region_overlay(ui, &p, &map, ®ions, &mut app.ui.name_edit) {- Some(RegionEdit::SetUp) => {- app.ui.name_edit = None;- super::faces::take_step(app, ui.ctx(), setup);- }- Some(RegionEdit::Remove(index)) => {- let _ = app.run("photo.removeRegion", json!({"id": id.0, "index": index}));- }- Some(RegionEdit::Name(index, name)) => {- app.ui.name_edit = None;- let _ = app.run("faces.setName", json!({"id": id.0, "index": index, "name": name}));- }- Some(RegionEdit::Resize(index, r)) => {- let _ = app.run("photo.setRegion", json!({"id": id.0, "index": index, "rect": {"x0": r.x0, "y0": r.y0, "x1": r.x1, "y1": r.y1}}));- }- None => {}- }- }- if app.ui.settings.focus_point && !crop_tool {- draw_focus_point(&p.with_clip_rect(img_rect.intersect(canvas)), img_rect, &photo, "canvas:focusPoint");- }- // a fine grid while a transform (geometry) slider is dragged, to judge verticals- if app.ui.dragging_control.as_deref().is_some_and(|c| c.starts_with("geometry.")) {- let n = 12;- let stroke = Stroke::new(1.0, Color32::from_white_alpha(70));- for i in 1..n {- let fx = img_rect.left() + img_rect.width() * i as f32 / n as f32;- p.line_segment([pos2(fx, img_rect.top()), pos2(fx, img_rect.bottom())], stroke);- }- let rows = ((n as f32) * img_rect.height() / img_rect.width()).round().max(2.0) as usize;- for i in 1..rows {- let fy = img_rect.top() + img_rect.height() * i as f32 / rows as f32;- p.line_segment([pos2(img_rect.left(), fy), pos2(img_rect.right(), fy)], stroke);- }- }+ let over = OverPhoto { photo: &photo, d: &d, map: &map, canvas, img_rect, fullscreen, crop_tool, clipping: !show_before };+ photo_overlays(app, ui, &p, &over);// Cursor selection must also run on gesture frames, when tool input is suppressed.if !matches!(right, RightPanel::Crop | RightPanel::Masking | RightPanel::Remove | RightPanel::RedEye) {general_cursor(app, ui, &resp, img_rect, main_area);}if !navigating {- match right {- RightPanel::Crop => crop_overlay(app, ui, &resp, &map, &frame, &d, id),- RightPanel::Masking => mask_overlay(app, ui, &resp, &map, &d),- RightPanel::Remove => remove_overlay(app, ui, &resp, &map, &d),- RightPanel::RedEye => eye_overlay(app, ui, &resp, &map, &d),- _ => {- // side by side / stacked: Before shows the same frame, so a click in its view (white- // balance, colour samples, targeted adjustment) means the same point of the photo.- // Zoomed in, a view's image reaches past its pane: what counts is the pane clicked.- // A click-zoom there centres both views on the point clicked (#1742).- let pointer = resp.interact_pointer_pos().or(resp.hover_pos());- let (map, img, pane) = match (split, areas.first(), pointer) {- (true, Some(before), Some(q)) if before.contains(q) => (CanvasMap::new(&frame, before_img), before_img, *before),- _ => (map, img_rect, main_area),- };- general_interaction(app, ui, &resp, &map, &PhotoPlacement { img, canvas: pane, native, aspect })- }- }+ let tv = ToolView { right, map: &map, frame: &frame, d: &d, id, split, native, aspect };+ tool_interaction(app, ui, &resp, &tv, &Views { img_rect, target_rect, before_img, before_target, areas: &areas, main_area, canvas });}// drawn and hit-tested above the loupe and its tools: clicks on it panlet nav = navigator(app, ui, canvas, img_rect, id);// what is on screen isn't the render on its way (a stand-in, the last render after an edit,// a magnified frame under its window): say so once that has lasted a moment- let whole: &[Slot] = if show_before && !split {- &[Slot::Before]- } else if split || split_view {- &[Slot::Main, Slot::Before]- } else {- &[Slot::Main]- };- let coming = !matches!(shown, "none" | "hover")- && whole.iter().chain(windows.iter().map(|(v, _)| &v.slot)).any(|s| app.renderer.is_pending(*s) && !app.renderer.retrying(*s));+ let coming = render_coming(app, shown, &windows, ViewMode { split, show_before, split_view });let keys =[Slot::Main, Slot::Before, Slot::Region, Slot::RegionBefore].map(|s| app.renderer.textures.get(&s).filter(|t| t.photo == id).map(|t| t.key));let rendering = ui.ctx().data_mut(|d| rendering_overdue(d.get_temp_mut_or(egui::Id::unique("loupe-rendering"), None), keys, coming, now));// the render failed while a stand-in is up: what is on screen is all there will be (also while// a library change retries it)- let failed = (!rendering- && (!show_before || split)- && !matches!(shown, "render" | "none" | "hover")- && (!app.renderer.is_pending(Slot::Main) || app.renderer.retrying(Slot::Main)))- .then(|| app.renderer.failure_of(Slot::Main, id))- .flatten();+ let failed = failed_render(app, id, !rendering && (!show_before || split), shown);if rendering || failed.is_some() {- // over the photo (the After in two views); in the crop tool's wide margin, under itlet over = if crop_tool { canvas } else { img_rect.intersect(if split { main_area } else { canvas }) };let over = if over.is_positive() { over } else { canvas };- match failed {- Some(e) => failed_pill(ui, app, &photo, canvas, over, nav, "loupe:renderFailed", e),- // View Options' Show message when loading or rendering photos- None if app.ui.settings.loupe_messages => {- loupe_pill(ui, canvas, over, nav, "loupe:rendering", crate::i18n::tr("Rendering…"), false);- }- None => {}- }+ status_pill(ui, app, &photo, [canvas, over], nav, failed);}- if let Some(why) = photo.preview_only.as_deref().filter(|_| !fullscreen) {- preview_only_pill(ui, canvas, why);+ if !fullscreen {+ photo.preview_only.as_deref().inspect(|why| preview_only_pill(ui, canvas, why));}- crate::widgets::context_menu(&resp, |ui| {+ loupe_context_menu(app, &resp, id);+}++/// The loupe's right-click menu: zoom commands and the grid's photo menu.+fn loupe_context_menu(app: &mut LightcraftApp, resp: &egui::Response, id: PhotoId) {+ crate::widgets::context_menu(resp, |ui| {crate::widgets::menu_button(ui, crate::i18n::tr("Zoom"), |ui| {for (label, cmd) in [("Fit", "view.zoomFit"), ("100%", "view.zoom100"), ("Zoom In", "view.zoomIn"), ("Zoom Out", "view.zoomOut")] {if ui.button(crate::i18n::tr(label)).clicked() {@@ -654,6 +371,512 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {});}+/// A fine grid while a transform (geometry) slider is dragged, to judge verticals.+fn transform_grid(app: &LightcraftApp, p: &egui::Painter, img_rect: Rect) {+ if app.ui.dragging_control.as_deref().is_some_and(|c| c.starts_with("geometry.")) {+ let n = 12;+ let stroke = Stroke::new(1.0, Color32::from_white_alpha(70));+ for i in 1..n {+ let fx = img_rect.left() + img_rect.width() * i as f32 / n as f32;+ p.line_segment([pos2(fx, img_rect.top()), pos2(fx, img_rect.bottom())], stroke);+ }+ let rows = ((n as f32) * img_rect.height() / img_rect.width()).round().max(2.0) as usize;+ for i in 1..rows {+ let fy = img_rect.top() + img_rect.height() * i as f32 / rows as f32;+ p.line_segment([pos2(img_rect.left(), fy), pos2(img_rect.right(), fy)], stroke);+ }+ }+}++/// The photo's face boxes and the name box on them.+fn face_boxes(+ app: &mut LightcraftApp,+ ui: &mut egui::Ui,+ p: &egui::Painter,+ map: &CanvasMap,+ photo: &lightcraft_catalog::Photo,+ d: &DevelopSettings,+) {+ let id = photo.id;+ // a name box left open on another photo is dropped+ if app.ui.name_edit.as_ref().is_some_and(|e| e.photo != id.0) {+ app.ui.name_edit = None;+ }+ let hints = super::faces::hints_for(app, id.0);+ let people = if app.ui.name_edit.is_some() { app.caches.person_names(&app.session.catalog) } else { Default::default() };+ // while the name box is open and recognition is not set up, the box offers the next step+ let setup = if app.ui.name_edit.is_some() { super::faces::setup(app, ui.ctx()) } else { super::faces::Setup::Running };+ let regions = RegionContext { photo, orient: d.orientation, hints: hints.as_deref(), people: &people, setup };+ match region_overlay(ui, p, map, ®ions, &mut app.ui.name_edit) {+ Some(RegionEdit::SetUp) => {+ app.ui.name_edit = None;+ super::faces::take_step(app, ui.ctx(), setup);+ }+ Some(RegionEdit::Remove(index)) => {+ let _ = app.run("photo.removeRegion", json!({"id": id.0, "index": index}));+ }+ Some(RegionEdit::Name(index, name)) => {+ app.ui.name_edit = None;+ let _ = app.run("faces.setName", json!({"id": id.0, "index": index, "name": name}));+ }+ Some(RegionEdit::Resize(index, r)) => {+ let _ = app.run("photo.setRegion", json!({"id": id.0, "index": index, "rect": {"x0": r.x0, "y0": r.y0, "x1": r.x1, "y1": r.y1}}));+ }+ None => {}+ }+}++/// A wipe shows the Before whole-frame render on its side of the line.+fn draw_wipe_before(app: &LightcraftApp, p: &egui::Painter, id: PhotoId, img_rect: Rect, line: Pos2) {+ if app.ui.before_after == BeforeAfter::Split+ && let Some(tex) = app.renderer.textures.get(&Slot::Before).filter(|t| t.photo == id)+ {+ let before_rect = fit_texture_rect(img_rect, tex.size);+ let u = ((line.x - before_rect.left()) / before_rect.width().max(1.0)).clamp(0.0, 1.0);+ let left = Rect::from_min_max(before_rect.min, pos2(before_rect.left() + u * before_rect.width(), before_rect.bottom()));+ p.image(tex.tex.id(), left, Rect::from_min_max(pos2(0.0, 0.0), pos2(u, 1.0)), Color32::WHITE);+ }+ if app.ui.before_after == BeforeAfter::SplitTopBottom+ && let Some(tex) = app.renderer.textures.get(&Slot::Before).filter(|t| t.photo == id)+ {+ let before_rect = fit_texture_rect(img_rect, tex.size);+ let v = ((line.y - before_rect.top()) / before_rect.height().max(1.0)).clamp(0.0, 1.0);+ let top = Rect::from_min_max(before_rect.min, pos2(before_rect.right(), before_rect.top() + v * before_rect.height()));+ p.image(tex.tex.id(), top, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, v)), Color32::WHITE);+ }+}++/// Once a photo is on screen, prepare its neighbours in filmstrip order (source decoded and kept,+/// view render cached) so stepping to them is instant.+fn prefetch_neighbours(app: &mut LightcraftApp, id: PhotoId, main_area: Rect, ppp: f32, texture_side: usize, with_crop: bool) {+ // only once this photo is on screen+ if app.renderer.is_pending(Slot::Main) || !app.renderer.textures.get(&Slot::Main).is_some_and(|t| t.photo == id) {+ return;+ }+ let ids = app.session.visible_cloned();+ if let Some(i) = ids.iter().position(|p| *p == id) {+ let next = ids.get(i + 1).copied();+ let prev = i.checked_sub(1).and_then(|j| ids.get(j)).copied();+ for (n, nid) in [next, prev].into_iter().enumerate() {+ let Some(nid) = nid else { continue };+ let Some(np) = app.session.catalog.photo(nid).cloned() else { continue };+ let nf = Frame::with_lens(np.width.max(1) as usize, np.height.max(1) as usize, &np.develop, with_crop, np.embedded_lens.as_ref());+ let na = nf.aspect() as f32;+ let nr = fit_rect(main_area, na, app.ui.zoom, output_px(&nf), ppp, app.ui.pan);+ let nw = app.ui.settings.prefetch_edge(nr.width().max(nr.height()) * ppp, output_px(&nf).into_iter().max().unwrap_or(1), texture_side);+ let (w, h) = if na >= 1.0 { (nw, (nw as f32 / na) as usize) } else { ((nw as f32 * na) as usize, nw) };+ if let Some(job) = app.session.loupe_job(nid, w.max(8), h.max(8), with_crop) {+ app.renderer.prefetch(Slot::Prefetch(n as u8), job, PREFETCH_PRIORITY);+ }+ }+ }+}++/// The rects of the two views of a before/after (side by side or stacked), else the one area.+fn view_areas(mode: BeforeAfter, area: Rect) -> Vec<Rect> {+ match mode {+ BeforeAfter::SideBySide => {+ let half = area.width() / 2.0 - 6.0;+ vec![+ Rect::from_min_size(area.min, vec2(half, area.height())),+ Rect::from_min_size(pos2(area.center().x + 6.0, area.top()), vec2(half, area.height())),+ ]+ }+ BeforeAfter::TopBottom => {+ let half = area.height() / 2.0 - 14.0;+ vec![+ Rect::from_min_size(area.min, vec2(area.width(), half)),+ Rect::from_min_size(pos2(area.left(), area.center().y + 14.0), vec2(area.width(), half)),+ ]+ }+ _ => vec![area],+ }+}++/// Which before/after layout is up.+#[derive(Clone, Copy)]+struct ViewMode {+ split: bool,+ show_before: bool,+ split_view: bool,+}++/// The rects the loupe's views are drawn in.+struct Views<'a> {+ img_rect: Rect,+ target_rect: Rect,+ before_img: Rect,+ before_target: Rect,+ areas: &'a [Rect],+ main_area: Rect,+ canvas: Rect,+}++/// The window renders wanted for the layout: (slot, before side?, rect to draw in, rect it is+/// requested for, area whose pixels show).+fn window_views(mode: ViewMode, v: &Views) -> Vec<WindowView> {+ let mut out: Vec<WindowView> = Vec::new();+ let after = WindowView { slot: Slot::Region, before: false, img: v.img_rect, target: v.target_rect, visible: v.main_area };+ if mode.split {+ out.push(WindowView {+ slot: Slot::RegionBefore,+ before: true,+ img: v.before_img,+ target: v.before_target,+ visible: v.areas.first().copied().unwrap_or(v.canvas),+ });+ out.push(after);+ } else if mode.show_before {+ out.push(WindowView { slot: Slot::RegionBefore, before: true, img: v.img_rect, target: v.target_rect, visible: v.canvas });+ } else if mode.split_view {+ out.push(WindowView { slot: Slot::RegionBefore, before: true, img: v.img_rect, target: v.target_rect, visible: v.canvas });+ out.push(WindowView { visible: v.canvas, ..after });+ } else {+ out.push(WindowView { visible: v.canvas, ..after });+ }+ out+}++/// What the canvas says when nothing could be drawn: why the photo failed, or that it is rendering.+fn none_message(app: &LightcraftApp, p: &egui::Painter, t: &Tokens, canvas: Rect, id: PhotoId) {+ match app.renderer.failure_of(Slot::Main, id) {+ Some(e) => {+ p.text(canvas.center() - vec2(0.0, 10.0), Align2::CENTER_CENTER, crate::i18n::tr("This photo can't be opened"), t.semibold(14.0), t.text);+ p.text(canvas.center() + vec2(0.0, 12.0), Align2::CENTER_CENTER, e, t.font(12.0), t.text_dim);+ }+ None if app.ui.settings.loupe_messages => {+ p.text(canvas.center(), Align2::CENTER_CENTER, crate::i18n::tr("Rendering…"), t.font(13.0), t.text_dim);+ }+ None => {}+ }+}++/// The render failed while a stand-in is up: what is on screen is all there will be (also while a+/// library change retries it).+fn failed_render<'a>(app: &'a LightcraftApp, id: PhotoId, settled: bool, shown: &str) -> Option<&'a str> {+ (settled && !matches!(shown, "render" | "none" | "hover") && (!app.renderer.is_pending(Slot::Main) || app.renderer.retrying(Slot::Main)))+ .then(|| app.renderer.failure_of(Slot::Main, id))+ .flatten()+}++/// The pill over the photo (the After in two views; in the crop tool's wide margin, under it): the+/// failure, or View Options' "Show message when loading or rendering photos".+fn status_pill(+ ui: &egui::Ui,+ app: &LightcraftApp,+ photo: &lightcraft_catalog::Photo,+ [canvas, over]: [Rect; 2],+ nav: Option<Rect>,+ failed: Option<&str>,+) {+ match failed {+ Some(e) => failed_pill(ui, app, photo, canvas, over, nav, "loupe:renderFailed", e),+ None if app.ui.settings.loupe_messages => {+ loupe_pill(ui, canvas, over, nav, "loupe:rendering", crate::i18n::tr("Rendering…"), false);+ }+ None => {}+ }+}++/// Soft proofing: a paper-white surround and the proof's name, as Lightroom shows it.+fn proof_surround(app: &LightcraftApp, p: &egui::Painter, t: &Tokens, canvas: Rect) {+ p.rect_filled(canvas, 0.0, Color32::from_gray(238));+ let label = crate::i18n::tr_format!("Proof Preview · {}", app.ui.proof.space.label());+ p.text(pos2(canvas.right() - 16.0, canvas.top() + 14.0), Align2::RIGHT_CENTER, label, t.font(12.5), Color32::from_gray(60));+}++/// Request the window renders, remember which sides have one, and release the slot of a side without.+fn request_windows(app: &mut LightcraftApp, ctx: &WindowCtx, views: Vec<WindowView>) -> Vec<(WindowView, crate::region::RegionView)> {+ let mut windows: Vec<(WindowView, crate::region::RegionView)> = Vec::new();+ for v in views {+ if let Some(view) = request_window(app, ctx, &v) {+ windows.push((v, view));+ }+ }+ for (slot, before) in [(Slot::Region, false), (Slot::RegionBefore, true)] {+ let shown = windows.iter().find(|(v, _)| v.before == before).map(|(_, view)| *view);+ if before {+ app.region_before_view = shown;+ } else {+ app.region_view = shown;+ }+ if shown.is_none() {+ app.region_tiles.retain(|(b, _), _| *b != before);+ app.renderer.release(slot);+ }+ }+ windows+}++/// The aspect of the texture on screen for this photo and geometry, if one is.+fn visible_texture_aspect(app: &LightcraftApp, id: PhotoId, d: &DevelopSettings, crop_tool: bool) -> Option<f32> {+ // A previous crop/rotation can stay visible while its replacement renders. Its pixels+ // must not override the current frame geometry, even when it is the same photo.+ let current_texture = |t: &&crate::render::Tex| t.photo == id && t.look == Some((crate::render::geometry_look(d), !crop_tool));+ app.renderer+ .textures+ .get(&Slot::Main)+ .filter(current_texture)+ .or_else(|| app.renderer.textures.get(&Slot::Preview).filter(current_texture))+ .or_else(|| app.renderer.thumb(id).filter(current_texture))+ .map(|tex| tex.size[0].max(1) as f32 / tex.size[1].max(1) as f32)+}++/// Whether the GPU draws the view (by the GPU's own rule, `handles`; `ready` first: `available`+/// would wait for a device still being created).+fn gpu_draws_view(app: &LightcraftApp, overlay: lightcraft_pipeline::Overlay) -> bool {+ lightcraft_engine::gpu::handles(+ lightcraft_pipeline::OutputDepth::U8,+ app.ui.soft_proof && lightcraft_pipeline::proof_profile(app.ui.proof.profile).is_some(),+ overlay,+ ) && lightcraft_engine::gpu::ready()+ && lightcraft_engine::gpu::available()+}++/// The line of a wipe.+fn draw_wipe_line(mode: BeforeAfter, p: &egui::Painter, img_rect: Rect, line: Pos2) {+ let stroke = Stroke::new(1.5, Color32::WHITE);+ match mode {+ BeforeAfter::Split => {+ p.line_segment([pos2(line.x, img_rect.top()), pos2(line.x, img_rect.bottom())], stroke);+ }+ BeforeAfter::SplitTopBottom => {+ p.line_segment([pos2(img_rect.left(), line.y), pos2(img_rect.right(), line.y)], stroke);+ }+ _ => {}+ }+}++/// Whether the render on its way is not what is on screen (a stand-in, the last render after an+/// edit, a magnified frame under its window).+fn render_coming(app: &LightcraftApp, shown: &str, windows: &[(WindowView, crate::region::RegionView)], mode: ViewMode) -> bool {+ let whole: &[Slot] = if mode.show_before && !mode.split {+ &[Slot::Before]+ } else if mode.split || mode.split_view {+ &[Slot::Main, Slot::Before]+ } else {+ &[Slot::Main]+ };+ !matches!(shown, "none" | "hover")+ && whole.iter().chain(windows.iter().map(|(v, _)| &v.slot)).any(|s| app.renderer.is_pending(*s) && !app.renderer.retrying(*s))+}++/// What the active tool needs to know about the loupe.+struct ToolView<'a> {+ right: RightPanel,+ map: &'a CanvasMap,+ frame: &'a Frame,+ d: &'a DevelopSettings,+ id: PhotoId,+ split: bool,+ native: [usize; 2],+ aspect: f32,+}++/// Route the pointer to the right panel's tool on the photo, or to the general interactions.+fn tool_interaction(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, tv: &ToolView, v: &Views) {+ let (map, d) = (tv.map, tv.d);+ match tv.right {+ RightPanel::Crop => crop_overlay(app, ui, resp, map, tv.frame, d, tv.id),+ RightPanel::Masking => mask_overlay(app, ui, resp, map, d),+ RightPanel::Remove => remove_overlay(app, ui, resp, map, d),+ RightPanel::RedEye => eye_overlay(app, ui, resp, map, d),+ _ => {+ // side by side / stacked: Before shows the same frame, so a click in its view (white+ // balance, colour samples, targeted adjustment) means the same point of the photo.+ // Zoomed in, a view's image reaches past its pane: what counts is the pane clicked.+ // A click-zoom there centres both views on the point clicked (#1742).+ let pointer = resp.interact_pointer_pos().or(resp.hover_pos());+ let (map, img, pane) = match (tv.split, v.areas.first(), pointer) {+ (true, Some(before), Some(q)) if before.contains(q) => (CanvasMap::new(tv.frame, v.before_img), v.before_img, *before),+ _ => (CanvasMap::new(tv.frame, v.img_rect), v.img_rect, v.main_area),+ };+ general_interaction(app, ui, resp, &map, &PhotoPlacement { img, canvas: pane, native: tv.native, aspect: tv.aspect })+ }+ }+}++/// The loupe's render plan, without a window for a view the GPU already refused one for.+fn loupe_plan(app: &LightcraftApp, id: PhotoId, look: u64, sizes: crate::region::ViewSizes) -> crate::region::LoupePlan {+ let plan = crate::region::plan(&app.ui.settings, sizes);+ if plan.window_edge.is_some_and(|edge| app.window_refused == Some((id, look, edge))) {+ return crate::region::plan(&app.ui.settings, crate::region::ViewSizes { windows: false, ..sizes });+ }+ plan+}++fn whole_frame_edge(app: &LightcraftApp, interacting: bool, plan: &crate::region::LoupePlan, native_long: usize, texture_side: usize) -> usize {+ if interacting || plan.window_edge.is_some() {+ plan.main_edge+ } else {+ // (a user's explicit Preview size below the preview level still caps it)+ let limit = if app.ui.settings.preview_limit == 0 { usize::MAX } else { app.ui.settings.preview_limit as usize };+ let floor = lightcraft_engine::SourceLevel::Preview.max_edge().min(limit).min(native_long);+ plan.main_edge.max(floor).min(texture_side.max(crate::state::MIN_TEXTURE_SIDE))+ }+}++/// What a loupe render request is for.+struct LoupeAsk {+ id: PhotoId,+ with_crop: bool,+ interacting: bool,+ fit_px: [usize; 2],+ overlay: lightcraft_pipeline::Overlay,+}++/// Request the loupe's own render at `[rw, rh]` (drafts during drags).+fn request_main(app: &mut LightcraftApp, ui: &egui::Ui, a: &LoupeAsk, [rw, rh]: [usize; 2], whole_draft: bool) {+ let (id, interacting, fit_px, overlay) = (a.id, a.interacting, a.fit_px, a.overlay);+ if let Some(job) = app.session.loupe_job(id, rw.max(8), rh.max(8), a.with_crop) {+ let job = if interacting { job.draft() } else { job };+ // at rest the render is shrunk to exactly the size it is drawn at with a Lanczos filter on+ // the worker, so the window draws it texel for texel instead of shrinking it with 2-tap+ // sampling (the render is up to a 64 px step larger, or the preview level)+ let job = if interacting { job } else { job.with_display_fit(fit_px[0], fit_px[1]) };+ let job = job.with_overlay(overlay).with_proof(app.ui.soft_proof.then_some(app.ui.proof));+ let job = job.with_hidden_grading(app.ui.grading_hidden_for(id));+ app.renderer.request(Slot::Main, job, 100);+ // a drag's draft that renders in a few ms (GPU) is drawn in this frame, not the next (zoomed+ // in, what changes on screen is the window's draft)+ #[cfg(not(target_arch = "wasm32"))]+ if interacting && whole_draft {+ let frame = ui.input(|i| i.predicted_dt).clamp(1.0 / 240.0, 1.0 / 30.0);+ // (a frame time that is not a number waits for nothing)+ let budget = std::time::Duration::try_from_secs_f32(frame * 0.4).unwrap_or_default();+ app.renderer.wait_for_draft(ui.ctx(), &mut app.session, budget);+ }+ }+}++/// Hovering a preset or profile: the photo with that look, shown instead of the loupe render once+/// it is ready (nothing is committed). The key of its render and the label to show.+fn request_hover(app: &mut LightcraftApp, a: &LoupeAsk, [sw, sh]: [usize; 2]) -> Option<(u64, String)> {+ match app.hover_preview.clone() {+ Some(h) if !a.interacting => app.session.preview_job(a.id, sw.max(8), sh.max(8), a.with_crop, &h.settings).map(|job| {+ // (the same display fit as the After view, drawn texel for texel like it)+ let job = job.with_display_fit(a.fit_px[0], a.fit_px[1]);+ let key = job.key;+ app.renderer.request(Slot::Hover, job, 105);+ (key, h.label)+ }),+ _ => None,+ }+}++/// The Before render, at the stand-in size.+fn request_before(app: &mut LightcraftApp, a: &LoupeAsk, [sw, sh]: [usize; 2]) {+ if let Some(job) = app.session.render_job(a.id, sw.max(8), sh.max(8), true, a.with_crop) {+ // (the same display fit as the After view, so both panes are the same texture size)+ let job = if a.interacting { job } else { job.with_display_fit(a.fit_px[0], a.fit_px[1]) };+ app.renderer.request(Slot::Before, job, 90);+ }+}++/// What a view slot shows: its own render of this photo, else the stand-ins (no blank frame+/// between photos, and the full render replaces them in place). Returns what it drew.+fn draw_slot(app: &LightcraftApp, p: &egui::Painter, id: PhotoId, ppp: f32, slot: Slot, r: Rect, clip: Rect) -> &'static str {+ let mine = |s: Slot| app.renderer.textures.get(&s).filter(|t| t.photo == id);+ let (tex, what) = if let Some(t) = mine(slot) {+ (t, "render")+ } else if let Some(t) = mine(Slot::Preview) {+ (t, t.quick.map(quick_name).unwrap_or("preview"))+ } else if let Some(t) = app.renderer.thumb(id) {+ (t, "thumb")+ } else {+ return "none";+ };+ let image_rect = snap_fit_rect(fit_texture_rect(r, tex.size), tex.size, ppp);+ p.with_clip_rect(clip).image(tex.tex.id(), image_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);+ what+}++/// The hovered look's render over the photo, with its label.+fn draw_hover(p: &egui::Painter, t: &Tokens, tex: &crate::render::Tex, label: &str, [img_rect, canvas]: [Rect; 2], badge_top_inset: f32) {+ let hover_rect = fit_texture_rect(img_rect, tex.size);+ p.image(tex.tex.id(), hover_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);+ let g = p.layout_no_wrap(label.to_string(), t.font(12.0), Color32::WHITE);+ let bg = label_badge_rect(hover_rect, canvas, g.size(), badge_top_inset);+ paint_badge(p, bg, g);+}++/// A label on a dark pill.+fn paint_badge(p: &egui::Painter, bg: Rect, g: std::sync::Arc<egui::Galley>) {+ p.rect_filled(bg, 4.0, Color32::from_black_alpha(160));+ p.galley(bg.min + vec2(8.0, 4.0), g, Color32::WHITE);+}++/// No photo is active: the empty-library message if the library is empty, else "No photo selected".+fn show_no_photo(app: &mut LightcraftApp, ui: &mut egui::Ui, canvas: Rect) {+ if super::empty_library::shown(&app.session) {+ super::empty_library::show(app, ui, canvas);+ } else {+ super::empty_message(ui, canvas, "No photo selected", "Choose a photo in the grid or filmstrip");+ }+}++/// The margin round the photo: none full screen, wide in the crop tool.+fn loupe_margin(fullscreen: bool, crop_tool: bool) -> f32 {+ if fullscreen {+ 0.0+ } else if crop_tool {+ 48.0+ } else {+ 24.0+ }+}++/// The labels under each photo, or under its pane when the photo reaches past it.+fn split_labels(p: &egui::Painter, t: &Tokens, [before, after]: [(Rect, Rect); 2]) {+ let label_at = |r: Rect, pane: Rect| pos2(r.left().max(pane.left()), r.bottom().min(pane.bottom()) + 14.0);+ p.text(label_at(before.0, before.1), Align2::LEFT_CENTER, crate::i18n::tr("Before"), t.font(12.0), t.text_dim);+ p.text(label_at(after.0, after.1), Align2::LEFT_CENTER, crate::i18n::tr("After"), t.font(12.0), t.text_dim);+}++/// What is drawn over the photo.+struct OverPhoto<'a> {+ photo: &'a lightcraft_catalog::Photo,+ d: &'a DevelopSettings,+ map: &'a CanvasMap,+ canvas: Rect,+ img_rect: Rect,+ fullscreen: bool,+ crop_tool: bool,+ /// the clipping overlay may show (not in the Before view)+ clipping: bool,+}++/// The overlays over the photo: clipping, layout image, info, filter pill, faces, focus point and+/// the transform grid.+fn photo_overlays(app: &mut LightcraftApp, ui: &mut egui::Ui, p: &egui::Painter, o: &OverPhoto) {+ let (canvas, img_rect) = (o.canvas, o.img_rect);+ if app.ui.show_clipping && o.clipping && !o.fullscreen {+ clipping_overlay(app, p, img_rect);+ }+ // View ▸ Loupe Overlay ▸ Layout Image, over the photo (the After view in a before/after)+ super::layout_overlay::draw(app, p, img_rect);+ register(ui, "canvas:image", img_rect);+ info_overlay(app, p, canvas, o.photo);+ if !o.fullscreen {+ filter_pill(app, ui, canvas);+ }+ if app.ui.face_boxes {+ face_boxes(app, ui, p, o.map, o.photo, o.d);+ }+ if app.ui.settings.focus_point && !o.crop_tool {+ draw_focus_point(&p.with_clip_rect(img_rect.intersect(canvas)), img_rect, o.photo, "canvas:focusPoint");+ }+ transform_grid(app, p, img_rect);+}++fn request_stand_in(app: &mut LightcraftApp, id: PhotoId, edge: usize, with_crop: bool) {+ if app.renderer.textures.get(&Slot::Main).is_none_or(|t| t.photo != id)+ && let Some(q) = app.session.quick_view_job(id, edge.max(8), with_crop)+ {+ app.renderer.request_quick(Slot::Preview, q, 110);+ }+}+/// Neighbour prefetch: below on-screen thumbnails, above background thumbnail refreshes.const PREFETCH_PRIORITY: u32 = 4;diff --git a/crates/ui-egui/src/panels/detail/masks.rs b/crates/ui-egui/src/panels/detail/masks.rsindex c150eac53..365ae2311 100644--- a/crates/ui-egui/src/panels/detail/masks.rs+++ b/crates/ui-egui/src/panels/detail/masks.rs@@ -291,7 +291,6 @@ pub(super) fn color_range_pick(app: &mut LightcraftApp, ui: &egui::Ui, resp: &eg/// component (click selects its mask, drag moves the component), and brush painting. The mask/// itself shows as a rendered overlay ([`view_overlay`]).pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, d: &DevelopSettings) {- let long = (map.rect.width().max(map.rect.height())) as f64;let active = app.session.active_mask;let clip = app.canvas_rect.unwrap_or(map.rect);let p = &ui.painter_at(clip);@@ -310,60 +309,9 @@ pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &eg// mask so nothing else becomes draggable. The component check keeps this in step with the// painted region (`view_overlay` at detail.rs:1354 only covers masks with components).let show_outline = sel || (app.ui.mask_overlay_all && m.visible && !m.components.is_empty());- let stroke_a: u8 = if sel { 230 } else { 170 };for (ci, c) in m.components.iter().enumerate() {- match &c.shape {- MaskShape::Radial { center, rx, ry, angle, .. } if show_outline => {- let pts: Vec<Pos2> = (0..64)- .map(|i| {- let a = i as f64 / 64.0 * std::f64::consts::TAU;- let (s, co) = angle.to_radians().sin_cos();- let (x, y) = (rx * a.cos(), ry * a.sin());- let l = frame_long_norm(map);- map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1))- })- .collect();- p.add(egui::Shape::closed_line(pts, Stroke::new(1.5, Color32::from_white_alpha(stroke_a))));-- if sel {- let l = frame_long_norm(map);- for (i, a_deg) in [0.0_f64, 90.0_f64, 180.0_f64, 270.0_f64].into_iter().enumerate() {- let a_local = a_deg.to_radians();- let (s, co) = angle.to_radians().sin_cos();- let (x, y) = (rx * a_local.cos(), ry * a_local.sin());- let q = map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1));- p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));- register(ui, format!("maskHandle:{}:{ci}:{}", m.id, i + 1), Rect::from_center_size(q, vec2(14.0, 14.0)));- grips.push((m.id, ci, i as u8 + 1, q));- }-- let (s, co) = angle.to_radians().sin_cos();- let rot_r = rx + 0.08;- let rot_q = map.screen(Point::new(center.x + (rot_r * co) * l.0, center.y + (rot_r * s) * l.1));- let h1_q = map.screen(Point::new(center.x + (rx * co) * l.0, center.y + (rx * s) * l.1));- p.line_segment([h1_q, rot_q], Stroke::new(1.0, Color32::from_white_alpha(200)));- p.circle_stroke(rot_q, 4.0, Stroke::new(1.5, Color32::WHITE));- register(ui, format!("maskHandle:{}:{ci}:5", m.id), Rect::from_center_size(rot_q, vec2(14.0, 14.0)));- grips.push((m.id, ci, 5, rot_q));- }- }- MaskShape::Linear { start, end } if show_outline => {- let (a, b) = (map.screen(*start), map.screen(*end));- let dir = (b - a).normalized();- let perp = vec2(-dir.y, dir.x) * 3000.0;- let (a1, a2): (u8, u8) = if sel { (230, 110) } else { (170, 80) };- for (q, alpha) in [(a, a1), (b, a2)] {- p.line_segment([q - perp, q + perp], Stroke::new(1.0, Color32::from_white_alpha(alpha)));- }- if sel {- for (i, q) in [a, b].iter().enumerate() {- p.circle_stroke(*q, 5.0, Stroke::new(1.5, Color32::WHITE));- register(ui, format!("maskHandle:{}:{ci}:{i}", m.id), Rect::from_center_size(*q, vec2(14.0, 14.0)));- grips.push((m.id, ci, i as u8 + 1, *q));- }- }- }- _ => {}+ if show_outline {+ component_outline(ui, p, map, (m.id, ci), &c.shape, sel, &mut grips);}if app.ui.mask_pins&& mode.shows(sel, live)@@ -377,8 +325,98 @@ pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &eg}}mask_keys(app, ui, map, d, &grips);- // Object selections (SAM 3) of the selected mask: each click, green to include, red to exclude- // (clicks still on their way to the model included)+ object_marks(app, p, map, d, active);+ // Colour Range "Pick": the Masking panel owns the loupe's clicks (general_interaction+ // never runs while it is open), so the eyedropper is handled here too.+ if app.ui.tool == "colorRange" {+ if resp.hovered() {+ ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);+ }+ color_range_pick(app, ui, resp, map);+ return;+ }+ if app.ui.tool == "object" {+ object_tool(app, ui, resp, map);+ return;+ }+ if app.ui.tool == "brush" {+ brush_tool(app, ui, resp, map, p, clip);+ return;+ }+ grip_gestures(app, ui, resp, map, d, &grips);+}++/// The outline of one mask component, and (on the selected mask) its grips, registered and+/// collected into `grips`.+fn component_outline(+ ui: &egui::Ui,+ p: &egui::Painter,+ map: &CanvasMap,+ at: (u32, usize),+ shape: &MaskShape,+ sel: bool,+ grips: &mut Vec<(u32, usize, u8, Pos2)>,+) {+ let (mask, ci) = at;+ let stroke_a: u8 = if sel { 230 } else { 170 };+ match shape {+ MaskShape::Radial { center, rx, ry, angle, .. } => {+ let pts: Vec<Pos2> = (0..64)+ .map(|i| {+ let a = i as f64 / 64.0 * std::f64::consts::TAU;+ let (s, co) = angle.to_radians().sin_cos();+ let (x, y) = (rx * a.cos(), ry * a.sin());+ let l = frame_long_norm(map);+ map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1))+ })+ .collect();+ p.add(egui::Shape::closed_line(pts, Stroke::new(1.5, Color32::from_white_alpha(stroke_a))));++ if sel {+ let l = frame_long_norm(map);+ for (i, a_deg) in [0.0_f64, 90.0_f64, 180.0_f64, 270.0_f64].into_iter().enumerate() {+ let a_local = a_deg.to_radians();+ let (s, co) = angle.to_radians().sin_cos();+ let (x, y) = (rx * a_local.cos(), ry * a_local.sin());+ let q = map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1));+ p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));+ register(ui, format!("maskHandle:{}:{ci}:{}", mask, i + 1), Rect::from_center_size(q, vec2(14.0, 14.0)));+ grips.push((mask, ci, i as u8 + 1, q));+ }++ let (s, co) = angle.to_radians().sin_cos();+ let rot_r = rx + 0.08;+ let rot_q = map.screen(Point::new(center.x + (rot_r * co) * l.0, center.y + (rot_r * s) * l.1));+ let h1_q = map.screen(Point::new(center.x + (rx * co) * l.0, center.y + (rx * s) * l.1));+ p.line_segment([h1_q, rot_q], Stroke::new(1.0, Color32::from_white_alpha(200)));+ p.circle_stroke(rot_q, 4.0, Stroke::new(1.5, Color32::WHITE));+ register(ui, format!("maskHandle:{}:{ci}:5", mask), Rect::from_center_size(rot_q, vec2(14.0, 14.0)));+ grips.push((mask, ci, 5, rot_q));+ }+ }+ MaskShape::Linear { start, end } => {+ let (a, b) = (map.screen(*start), map.screen(*end));+ let dir = (b - a).normalized();+ let perp = vec2(-dir.y, dir.x) * 3000.0;+ let (a1, a2): (u8, u8) = if sel { (230, 110) } else { (170, 80) };+ for (q, alpha) in [(a, a1), (b, a2)] {+ p.line_segment([q - perp, q + perp], Stroke::new(1.0, Color32::from_white_alpha(alpha)));+ }+ if sel {+ for (i, q) in [a, b].iter().enumerate() {+ p.circle_stroke(*q, 5.0, Stroke::new(1.5, Color32::WHITE));+ register(ui, format!("maskHandle:{}:{ci}:{i}", mask), Rect::from_center_size(*q, vec2(14.0, 14.0)));+ grips.push((mask, ci, i as u8 + 1, *q));+ }+ }+ }+ _ => {}+ }+}++/// Object selections (SAM 3) of the selected mask: each click, green to include, red to exclude+/// (clicks still on their way to the model included).+fn object_marks(app: &LightcraftApp, p: &egui::Painter, map: &CanvasMap, d: &DevelopSettings, active: Option<u32>) {let pending = app.session.segmenter.pending_clicks().cloned();for m in d.masks.iter().filter(|m| Some(m.id) == active) {for (k, c) in m.components.iter().enumerate() {@@ -397,100 +435,104 @@ pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &eg}}}- // Colour Range "Pick": the Masking panel owns the loupe's clicks (general_interaction- // never runs while it is open), so the eyedropper is handled here too.- if app.ui.tool == "colorRange" {- if resp.hovered() {- ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);- }- color_range_pick(app, ui, resp, map);- return;+}++/// Object tool: a click includes what's under it, ⌥-click leaves it out.+fn object_tool(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap) {+ if resp.hovered() {+ ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);}- // Object tool: a click includes what's under it, ⌥-click leaves it out- if app.ui.tool == "object" {- if resp.hovered() {- ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);- }- if resp.clicked()- && let Some(q) = resp.interact_pointer_pos()- {- let n = map.norm(q);- let exclude = ui.input(|i| i.modifiers.alt);- match app.run_typed("mask.objectPoint", json!({"x": n.x, "y": n.y, "exclude": exclude})) {- Ok(_) => {- if let Some(mid) = app.session.active_mask {- app.ui.detail_due = Some((app.tick_now() + 1.0, mid));- }+ if resp.clicked()+ && let Some(q) = resp.interact_pointer_pos()+ {+ let n = map.norm(q);+ let exclude = ui.input(|i| i.modifiers.alt);+ match app.run_typed("mask.objectPoint", json!({"x": n.x, "y": n.y, "exclude": exclude})) {+ Ok(_) => {+ if let Some(mid) = app.session.active_mask {+ app.ui.detail_due = Some((app.tick_now() + 1.0, mid));}- Err(e) => app.ai_error(ui.ctx(), e, Some(("object", "new"))),}+ Err(e) => app.ai_error(ui.ctx(), e, Some(("object", "new"))),}- return;}- // brush tool- if app.ui.tool == "brush" {- let r = (app.ui.brush_size as f64 * long) as f32;- if let Some(h) = resp.hover_pos() {- ui.ctx().set_cursor_icon(egui::CursorIcon::None);- p.circle_stroke(h, r, Stroke::new(1.0, Color32::WHITE));- p.circle_stroke(h, r * (1.0 - app.ui.brush_feather / 100.0).max(0.05), Stroke::new(1.0, Color32::from_white_alpha(120)));- }- if let Some(q) = resp.interact_pointer_pos()- && (resp.drag_started() || resp.dragged() || resp.clicked())- {- let n = map.norm(q);- let force = if app.ui.brush_pressure { ui.input(pen_force) } else { None };- match &mut app.gesture {- // a held, unmoving pointer records nothing: coverage builds by passes, not time (#518)- Some(Gesture::Brush { points, .. }) if points.last() == Some(&n) => {}- Some(Gesture::Brush { points, pressure }) => {- record_pressure(pressure, points.len(), force);- points.push(n);- }- _ => {- let mut pressure = Vec::new();- record_pressure(&mut pressure, 0, force);- app.gesture = Some(Gesture::Brush { points: vec![n], pressure });- }+}++/// Brush tool: the cursor, the stroke being painted and its commit.+fn brush_tool(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, p: &egui::Painter, clip: Rect) {+ let long = (map.rect.width().max(map.rect.height())) as f64;+ let r = (app.ui.brush_size as f64 * long) as f32;+ if let Some(h) = resp.hover_pos() {+ ui.ctx().set_cursor_icon(egui::CursorIcon::None);+ p.circle_stroke(h, r, Stroke::new(1.0, Color32::WHITE));+ p.circle_stroke(h, r * (1.0 - app.ui.brush_feather / 100.0).max(0.05), Stroke::new(1.0, Color32::from_white_alpha(120)));+ }+ if let Some(q) = resp.interact_pointer_pos()+ && (resp.drag_started() || resp.dragged() || resp.clicked())+ {+ let n = map.norm(q);+ let force = if app.ui.brush_pressure { ui.input(pen_force) } else { None };+ match &mut app.gesture {+ // a held, unmoving pointer records nothing: coverage builds by passes, not time (#518)+ Some(Gesture::Brush { points, .. }) if points.last() == Some(&n) => {}+ Some(Gesture::Brush { points, pressure }) => {+ record_pressure(pressure, points.len(), force);+ points.push(n);+ }+ _ => {+ let mut pressure = Vec::new();+ record_pressure(&mut pressure, 0, force);+ app.gesture = Some(Gesture::Brush { points: vec![n], pressure });}}- // the stroke being painted (the render shows it once it's committed), with the committed- // stroke's dab spacing, feather and flow (issue #517)- if let Some(Gesture::Brush { points, pressure }) = &app.gesture {- let screen: Vec<Pos2> = points.iter().map(|q| map.screen(*q)).collect();- let opacity = if app.ui.mask_overlay && app.ui.mask_overlay_opacity > 0.0 { app.ui.mask_overlay_opacity / 100.0 } else { 110.0 / 255.0 };- let params = crate::brush_live::LiveParams {- clip,- scale: ui.ctx().pixels_per_point(),- r,- hard: r * (1.0 - (app.ui.brush_feather / 100.0).clamp(0.0, 1.0)),- flow: (app.ui.brush_flow / 100.0).clamp(0.0, 1.0),- density: 1.0,- color: app.ui.mask_overlay_color,- opacity: opacity.clamp(0.0, 1.0),- };- crate::brush_live::paint(&mut app.brush_live, ui.ctx(), p, params, &screen, pressure);- } else {- app.brush_live = None;- }- if (resp.drag_stopped() || resp.clicked())- && let Some(Gesture::Brush { points, pressure }) = app.gesture.take()- {- app.brush_live = None;- let pts: Vec<[f64; 2]> = points.iter().map(|q| [q.x, q.y]).collect();- // holding ⌥ (Alt) paints with the other mode: Erase while adding, Add while erasing- let (alt, shift) = resp.ctx.input(|i| (i.modifiers.alt, i.modifiers.shift));- let erase = app.ui.brush_erase != alt;- // a ⇧-click draws a straight line from where the last stroke ended, as in Lightroom- let connect = shift && resp.clicked() && pts.len() == 1;- let _ = app.run(- "mask.brushStroke",- json!({"points": pts, "size": app.ui.brush_size, "feather": app.ui.brush_feather, "flow": app.ui.brush_flow,- "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure, "connect": connect}),- );- }- return;}+ // the stroke being painted (the render shows it once it's committed), with the committed+ // stroke's dab spacing, feather and flow (issue #517)+ if let Some(Gesture::Brush { points, pressure }) = &app.gesture {+ let screen: Vec<Pos2> = points.iter().map(|q| map.screen(*q)).collect();+ let opacity = if app.ui.mask_overlay && app.ui.mask_overlay_opacity > 0.0 { app.ui.mask_overlay_opacity / 100.0 } else { 110.0 / 255.0 };+ let params = crate::brush_live::LiveParams {+ clip,+ scale: ui.ctx().pixels_per_point(),+ r,+ hard: r * (1.0 - (app.ui.brush_feather / 100.0).clamp(0.0, 1.0)),+ flow: (app.ui.brush_flow / 100.0).clamp(0.0, 1.0),+ density: 1.0,+ color: app.ui.mask_overlay_color,+ opacity: opacity.clamp(0.0, 1.0),+ };+ crate::brush_live::paint(&mut app.brush_live, ui.ctx(), p, params, &screen, pressure);+ } else {+ app.brush_live = None;+ }+ if (resp.drag_stopped() || resp.clicked())+ && let Some(Gesture::Brush { points, pressure }) = app.gesture.take()+ {+ app.brush_live = None;+ let pts: Vec<[f64; 2]> = points.iter().map(|q| [q.x, q.y]).collect();+ // holding ⌥ (Alt) paints with the other mode: Erase while adding, Add while erasing+ let (alt, shift) = resp.ctx.input(|i| (i.modifiers.alt, i.modifiers.shift));+ let erase = app.ui.brush_erase != alt;+ // a ⇧-click draws a straight line from where the last stroke ended, as in Lightroom+ let connect = shift && resp.clicked() && pts.len() == 1;+ let _ = app.run(+ "mask.brushStroke",+ json!({"points": pts, "size": app.ui.brush_size, "feather": app.ui.brush_feather, "flow": app.ui.brush_flow,+ "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure, "connect": connect}),+ );+ }+}++/// Grabbing mask grips and component bodies: select, drag, release.+fn grip_gestures(+ app: &mut LightcraftApp,+ ui: &egui::Ui,+ resp: &egui::Response,+ map: &CanvasMap,+ d: &DevelopSettings,+ grips: &[(u32, usize, u8, Pos2)],+) {+ let active = app.session.active_mask;// the grip under the pointer: the selected mask's first, then the nearestlet hit = |q: Pos2| {grips