LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-VIEW-ZOOM: zoom windows cover a canvas wider than 2048 px (issue #652)
hxw3cdf18ba6db9
diff --git a/crates/ui-egui/src/headless.rs b/crates/ui-egui/src/headless.rsindex e6929269f..fdf5ecb69 100644--- a/crates/ui-egui/src/headless.rs+++ b/crates/ui-egui/src/headless.rs@@ -170,6 +170,9 @@ pub struct Headless {pub view: HeadlessView,/// The largest texture the pretend GPU takes (what a WebGL device may report: 2048).pub max_texture_side: usize,+ /// The limit egui was last told. Like a native host (egui-winit) it is reported once, not in+ /// every frame's input: code that reads the raw input sees `None` from then on (issue #652).+ reported_texture_side: Option<usize>,/// Logical size (points) and scale.pub size: egui::Vec2,pub pixels_per_point: f32,@@ -201,6 +204,7 @@ impl Headless {app,view: HeadlessView::new(),max_texture_side: 16384,+ reported_texture_side: None,size,pixels_per_point,time: 0.0,@@ -227,7 +231,8 @@ impl Headless {(self.size, self.pixels_per_point) = bounded_viewport(self.size, self.pixels_per_point);let mut raw = HeadlessView::raw_input(self.size, self.pixels_per_point, self.time, std::mem::take(&mut self.events));raw.viewports.entry(ViewportId::ROOT).or_default().maximized = Some(self.window_maximized);- raw.max_texture_side = Some(self.max_texture_side);+ raw.max_texture_side = (self.reported_texture_side != Some(self.max_texture_side)).then_some(self.max_texture_side);+ self.reported_texture_side = Some(self.max_texture_side);self.app.raw_input_hook(&mut raw);let app = &mut self.app;let commands = self.view.run(raw, |ui| {diff --git a/crates/ui-egui/src/panels/detail.rs b/crates/ui-egui/src/panels/detail.rsindex 2e708da66..cab305f0f 100644--- a/crates/ui-egui/src/panels/detail.rs+++ b/crates/ui-egui/src/panels/detail.rs@@ -187,10 +187,14 @@ pub(crate) fn navigate_gesture(app: &mut LightcraftApp, ui: &mut egui::Ui, resp:true}-/// The largest texture the GPU behind `ctx` takes (egui reports it; 2048 when it doesn't, the+/// The largest texture the GPU behind `ctx` takes (egui reports it; 2048 until it does, the/// smallest limit WebGL devices have).+///+/// The value egui keeps, not the frame's raw input: a native host (egui-winit) reports the limit+/// in the first frame's input only, so the raw value is `None` from the second frame on+/// (issue #652: every window render was cut to 2048 px, with blurry strips beside it).pub(crate) fn texture_side(ctx: &egui::Context) -> usize {- ctx.input(|i| i.raw.max_texture_side).unwrap_or(2048)+ ctx.input(|i| i.max_texture_side)}/// The photo's own pixels as it is shown: its size after the crop and the user's rotation (what@@ -2050,7 +2054,23 @@ fn straighten_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::R#[cfg(test)]mod tests {- use super::film_label;+ use super::{film_label, texture_side};++ /// Issue #652: a native host reports the GPU's texture limit in the first frame's input only.+ /// The loupe must still know it in every later frame (it read the raw input, found nothing and+ /// cut every window render to 2048 px).+ #[test]+ fn the_texture_limit_outlives_the_frame_it_was_reported_in() {+ let ctx = egui::Context::default();+ assert_eq!(texture_side(&ctx), 2048, "until the host says: the smallest limit there is");+ let mut seen = Vec::new();+ for reported in [Some(8192), None, None] {+ let raw = egui::RawInput { max_texture_side: reported, ..Default::default() };+ let mut out = ctx.run_ui(raw, |ui| seen.push(texture_side(ui.ctx())));+ out.textures_delta.clear();+ }+ assert_eq!(seen, [8192, 8192, 8192]);+ }#[test]fn film_labels_cut_on_characters_not_bytes() {diff --git a/crates/ui-egui/src/tests_preview_limit.rs b/crates/ui-egui/src/tests_preview_limit.rsindex 4b15cd179..f48a2e1c3 100644--- a/crates/ui-egui/src/tests_preview_limit.rs+++ b/crates/ui-egui/src/tests_preview_limit.rs@@ -352,6 +352,28 @@ mod in_the_loupe {}}+ // Issue #652: given a canvas wider than 2048 px on a desktop GPU (which reports its texture+ // limit to egui once, in the first frame), when I zoom to 1:1, then the window render covers+ // the whole canvas: no strip of the magnified whole-frame render beside it+ #[test]+ fn a_window_covers_a_canvas_wider_than_2048_px() {+ let (mut h, native) = detail_in([2600.0, 1200.0]);+ assert!(native > 2600, "the photo is wider than the canvas at 1:1: {native}");+ h.request("engine.execute", json!({"command": "view.zoom100"}), T);+ h.settle(SETTLE);+ let canvas = h.app.canvas_rect.expect("the loupe was drawn");+ let image = h.app.image_rect.expect("the photo was drawn");+ let region = h.app.region_view.expect("a window");+ // the canvas in pixels of the window's frame (scale 1, at 100 %: a point is a pixel)+ let to_px = region.full.0 as f32 / image.width();+ let (left, right) = (to_px * (canvas.left() - image.left()), to_px * (canvas.right() - image.left()));+ assert!(right - left > 2048.0, "the canvas shows more than 2048 px: {left}..{right}");+ let (x0, x1) = (region.window.x as f32, (region.window.x + region.window.w) as f32);+ assert!(x0 <= left + 0.5 && x1 >= right - 0.5, "the window {x0}..{x1} leaves part of the canvas {left}..{right} to the preview");+ let (w, _) = region_tile(&h).expect("the window rendered");+ assert_eq!(w, region.window.w, "and that is the texture drawn");+ }+// Given 400 % on a big photo, when a slider is dragged, then the work per frame follows the// canvas, not the zoom: a draft of the whole frame at canvas scale and a draft of the window#[test]