b45255bb6fe2
zoom_preview_tests.rs
//! Coarse previews while the zoom changes (#295): a new zoom first shows the whole view coarsely,
//! then the refined image, which matches a render from scratch; pans and edits still build on the
//! kept image; previews never replace a refined image that already shows the whole view asked
//! for, and no image of another file or page goes on screen. The browser's inline worker previews
//! by the same measure as the render thread. Renders from scratch with no measure to go by (the
//! first, another page, a zoom after quick renders) get a preview on the desktop only if they run
//! long, from the watchdog beside the render thread.
use std::sync::Arc;
use std::time::Duration;
use figcraft_doc::{Document, NodeId};
use figcraft_engine::Session;
use figcraft_engine::params::id_of;
use figcraft_render::{View, Work};
use serde_json::json;
use web_time::Instant;
use super::{CanvasState, shows};
use figcraft_render::Retained;
use crate::render_worker::{
Done, Inline, Job, PREVIEW_AFTER_MS, PREVIEW_FACTOR, Refined, Renders, SETTLE_MS, Worker, better, coarse_view, preview_with, render_now,
};
/// A page of ellipses with a rectangle on top; the session and the rectangle. The system fonts are
/// scanned first (once per process, and a concurrent caller waits for it): the scan another test
/// starts bumps the global font generation, and a render kept from before it is stale, so a pan
/// or an edit meanwhile would redraw in full instead of patching.
pub(super) fn document() -> (Session, NodeId) {
figcraft_text::scan_system_fonts();
let mut s = Session::new();
for k in 0..12 {
let k = f64::from(k);
s.execute("shape.ellipse", &json!({"x": k * 60.0, "y": k * 40.0, "width": 120, "height": 90})).unwrap();
}
let made = s.execute("shape.rectangle", &json!({"x": 100, "y": 50, "width": 300, "height": 200})).unwrap();
let rect = id_of(&made["id"]).unwrap();
(s, rect)
}
/// A page whose renders from scratch of each of `views` take at least `ms`: the rectangle with glass
/// and a background blur, and more and more blurred rectangles over the views until they do (a
/// fixed scene would turn quick on a faster machine or renderer).
fn slow_scene(views: &[View], ms: f64) -> Session {
let (mut s, rect) = document();
s.execute("effect.add", &json!({"ids": [rect], "type": "GLASS"})).unwrap();
s.execute("effect.add", &json!({"ids": [rect], "type": "BACKGROUND_BLUR"})).unwrap();
let area = views.iter().map(View::page_rect).reduce(|a, b| a.union(b)).unwrap();
let mut more = 8;
for _ in 0..12 {
let ds = s.ds().unwrap();
let quickest = views.iter().map(|v| render_now(&job(&ds.doc, ds.page, ds.uid, v.clone())).unwrap().ms).fold(f64::INFINITY, f64::min);
if quickest >= ms {
return s;
}
let (w, h) = (area.width() / 4.0, area.height() / 4.0);
let ids: Vec<NodeId> = (0..more)
.map(|k| {
let (fx, fy) = (f64::from(k * 37 % 101) / 101.0, f64::from(k * 59 % 103) / 103.0);
let p = json!({"x": area.x0 + fx * (area.width() - w), "y": area.y0 + fy * (area.height() - h), "width": w, "height": h});
id_of(&s.execute("shape.rectangle", &p).unwrap()["id"]).unwrap()
})
.collect();
s.execute("effect.add", &json!({"ids": ids, "type": "BACKGROUND_BLUR"})).unwrap();
more *= 2;
}
panic!("no scene renders slower than {ms} ms");
}
/// A `w` × `h` device-pixel view at `scale` centred on page point `c`.
pub(super) fn view_at(c: (f64, f64), scale: f64, w: u32, h: u32) -> View {
View { origin: (c.0 - f64::from(w) / scale / 2.0, c.1 - f64::from(h) / scale / 2.0), scale, width: w, height: h }
}
pub(super) fn job(doc: &Arc<Document>, page: NodeId, uid: u64, view: View) -> Job {
Job {
doc: doc.clone(),
page,
view,
outline: false,
outline_extras: Default::default(),
outlined: vec![],
skip: vec![],
solo: None,
proof: false,
dots: None,
uid,
zoom_preview: true,
at: Instant::now(),
}
}
/// Every pixel of `a` and `b` alike.
fn same_pixels(a: &Done, b: &Done) -> bool {
a.image.size == b.image.size && a.image.pixels == b.image.pixels
}
/// The same image up to where render bands meet ([`figcraft_render::Steps`] and the desktop's
/// parallel bands cut the view in different places): on each row, under a quarter of a level on
/// average and at most one pixel in twenty off.
fn close_pixels(a: &Done, b: &Done) -> bool {
let [w, h] = a.image.size;
a.image.size == b.image.size
&& (0..h).all(|y| {
let row = |d: &Done| d.image.pixels[y * w..(y + 1) * w].to_vec();
let (ra, rb) = (row(a), row(b));
let diffs: Vec<u32> =
ra.iter().zip(&rb).map(|(p, q)| p.to_array().iter().zip(q.to_array()).map(|(x, y)| u32::from(x.abs_diff(y))).sum()).collect();
let sum: u32 = diffs.iter().sum();
f64::from(sum) / (w as f64 * 4.0) < 0.25 && diffs.iter().filter(|d| **d > 0).count() * 20 <= w
})
}
/// Poll the browser's worker until it shows the full image (drawn band by band over polls): the
/// last image it hands out before nothing is left in flight. (Fonts another test loads meanwhile
/// make a render that is drawn show, then draw again: only the last one is the request's.)
fn refined(w: &mut Inline) -> Option<Done> {
refined_at(w, Instant::now())
}
/// [`refined`] with the worker's clock at `now`, so a wait it times is up to the test, not to how
/// busy the machine is.
fn refined_at(w: &mut Inline, now: Instant) -> Option<Done> {
let mut last = None;
for _ in 0..1000 {
last = w.poll_at(now).or(last);
if !w.in_flight() {
return last;
}
}
None
}
/// Refine `job` through `r` with no time to spare (a band a call); the image and how many calls.
fn stepped(r: &mut Renders, job: &Job) -> (Option<Done>, usize) {
for n in 1..1000 {
match r.refine_for(job, 0.0) {
Refined::Done(d) => return (d, n),
Refined::Shown(_) | Refined::More => {}
}
}
(None, 1000)
}
fn covers(outer: &View, inner: &View) -> bool {
let (o, i) = (outer.page_rect(), inner.page_rect());
let eps = 1e-6;
o.x0 <= i.x0 + eps && o.y0 <= i.y0 + eps && o.x1 >= i.x1 - eps && o.y1 >= i.y1 - eps
}
#[test]
fn a_zoom_out_previews_the_whole_view_then_refines_to_a_fresh_render() {
let (s, _) = document();
let ds = s.ds().unwrap();
let mut r = Renders::with_threshold(0.0);
let zoomed_in = job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 8.0, 400, 300));
assert!(r.preview(&zoomed_in).is_none(), "the first render has nothing to measure previews by");
assert!(r.refine(&zoomed_in).is_some());
// 800% → 100% about the same centre: the old image covers 1/64 of the new view.
let out = job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 1.0, 400, 300));
let p = r.preview(&out).expect("a preview first");
assert!(p.coarse && (p.uid, p.page) == (ds.uid, ds.page));
assert!(covers(&p.view, &out.view), "the preview shows the whole view asked for");
let pixels = |d: &Done| d.image.size[0] * d.image.size[1];
let fresh = render_now(&out).unwrap();
assert!(
(pixels(&p) as f64) * PREVIEW_FACTOR * PREVIEW_FACTOR < 1.5 * pixels(&fresh) as f64,
"a sixteenth of the pixels, give or take the snapping"
);
let refined = r.refine(&out).unwrap();
assert!(!refined.coarse && refined.work == Work::Full);
assert!(same_pixels(&refined, &fresh), "the settled image is a render from scratch");
}
/// Zoom, pan and edit with `r`; whether each step was previewed, and the pan's and the edit's
/// images.
fn zoom_pan_edit(r: &mut Renders) -> (Vec<bool>, Done, Done) {
let (mut s, rect) = document();
let (doc, page, uid) = {
let ds = s.ds().unwrap();
(ds.doc.clone(), ds.page, ds.uid)
};
r.refine(&job(&doc, page, uid, view_at((300.0, 200.0), 4.0, 1280, 960))).unwrap();
let mut previewed = vec![];
// A zoom; the preview is kept apart from the full image.
let zoomed = job(&doc, page, uid, view_at((300.0, 200.0), 2.0, 1280, 960));
previewed.push(r.preview(&zoomed).is_some());
r.refine(&zoomed).unwrap();
// A pan at that zoom.
let mut pan = zoomed;
pan.view.origin.0 += 10.0;
previewed.push(r.preview(&pan).is_some());
let panned = r.refine(&pan).unwrap();
// An edit there.
s.execute("node.set", &json!({"id": rect, "props": {"x": 120}})).unwrap();
let edit = job(&s.ds().unwrap().doc, page, uid, pan.view);
previewed.push(r.preview(&edit).is_some());
let edited = r.refine(&edit).unwrap();
(previewed, panned, edited)
}
#[test]
fn pans_and_edits_get_no_preview_and_build_on_the_kept_image() {
let (previewed, panned, edited) = zoom_pan_edit(&mut Renders::with_threshold(0.0));
assert_eq!(previewed, [true, false, false], "the zoom only");
assert!(matches!(panned.work, Work::Partial { .. }), "a pan after a previewed zoom renders strips only: {:?}", panned.work);
assert!(matches!(edited.work, Work::Partial { .. }), "an edit renders its area only: {:?}", edited.work);
// The same steps without previews: the same work and the same pixels.
let (none, panned_alone, edited_alone) = zoom_pan_edit(&mut Renders::with_threshold(f64::INFINITY));
assert_eq!(none, [false, false, false]);
assert_eq!((panned.work, edited.work), (panned_alone.work, edited_alone.work));
assert!(same_pixels(&panned, &panned_alone) && same_pixels(&edited, &edited_alone));
}
#[test]
fn previews_come_for_other_pages_and_files_but_not_in_pixel_preview_or_when_renders_are_quick() {
let (mut s, _) = document();
let (doc, page, uid) = {
let ds = s.ds().unwrap();
(ds.doc.clone(), ds.page, ds.uid)
};
let v = view_at((300.0, 200.0), 1.0, 200, 150);
let mut r = Renders::with_threshold(0.0);
r.refine(&job(&doc, page, uid, v.clone())).unwrap();
s.execute("page.add", &json!({})).unwrap();
let ds = s.ds().unwrap();
assert!(r.preview(&job(&ds.doc, ds.page, uid, v.clone())).is_some(), "another page");
assert!(r.preview(&job(&doc, page, uid + 1, v.clone())).is_some(), "another file");
let zoom = view_at((300.0, 200.0), 2.0, 200, 150);
let mut pixel_preview = job(&doc, page, uid, zoom.clone());
pixel_preview.zoom_preview = false;
assert!(r.preview(&pixel_preview).is_none(), "pixel preview shows real pixels only");
let mut quick = Renders::with_threshold(f64::INFINITY);
quick.refine(&job(&doc, page, uid, v)).unwrap();
assert!(quick.preview(&job(&doc, page, uid, zoom)).is_none(), "quick renders show without one");
}
#[test]
fn previews_cover_the_view_for_any_zoom_and_density() {
let (s, _) = document();
let ds = s.ds().unwrap();
let mut r = Renders::with_threshold(0.0);
r.refine(&job(&ds.doc, ds.page, ds.uid, view_at((0.0, 0.0), 0.37, 64, 64))).unwrap();
let mut n = 0;
// Zooms from 2% to 6400% at 1x, 1.5x and 2x displays, odd sizes, centres off the pixel grid.
for zoom in [0.02, 0.1, 0.333, 1.0, 2.5, 8.0, 64.0] {
for ppp in [1.0, 1.5, 2.0] {
for (w, h) in [(1, 1), (3, 7), (401, 299), (1280, 720)] {
let v = view_at((123.456, -78.9), zoom * ppp, w, h);
let c = coarse_view(&v);
assert!(covers(&c, &v), "coarse view of {v:?}");
let p = r.preview(&job(&ds.doc, ds.page, ds.uid, v.clone())).expect("a preview");
assert!(covers(&p.view, &v), "preview of {v:?} shows {:?}", p.view);
n += 1;
}
}
}
assert_eq!(n, 84);
}
#[test]
fn outline_mode_proofing_and_glass_preview_and_settle_like_fresh_renders() {
let (mut s, rect) = document();
s.execute("effect.add", &json!({"ids": [rect], "type": "GLASS"})).unwrap();
let ds = s.ds().unwrap();
for (outline, proof) in [(false, false), (true, false), (false, true)] {
let mut r = Renders::with_threshold(0.0);
let mut first = job(&ds.doc, ds.page, ds.uid, view_at((250.0, 150.0), 3.0, 300, 200));
(first.outline, first.proof) = (outline, proof);
r.refine(&first).unwrap();
let mut next = first.clone();
next.view = view_at((250.0, 150.0), 0.75, 300, 200);
let p = r.preview(&next).expect("a preview");
assert!(p.coarse && covers(&p.view, &next.view));
let d = r.refine(&next).unwrap();
assert!(same_pixels(&d, &render_now(&next).unwrap()), "outline {outline}, proof {proof}");
}
}
#[test]
fn the_canvas_shows_images_of_its_own_page_and_never_a_coarser_one_of_its_view() {
let (s, _) = document();
let ds = s.ds().unwrap();
let here = Some((ds.uid, ds.page));
let mut r = Renders::with_threshold(0.0);
let near = job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 2.0, 200, 150));
let refined = Done { seq: 1, ..r.refine(&near).unwrap() };
let far = job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 0.5, 200, 150));
let preview = Done { seq: 2, ..r.preview(&far).unwrap() };
let mut c = CanvasState { want_view: Some(near.view.clone()), ..Default::default() };
assert!(shows(&c, &refined, here));
assert!(!shows(&c, &refined, Some((ds.uid + 1, ds.page))), "another file");
assert!(!shows(&c, &refined, Some((ds.uid, NodeId(ds.page.0 + 1)))), "another page");
assert!(!shows(&c, &refined, None), "no file open");
// Showing the refined image of the view asked for: a preview arriving late stays off.
(c.tex_view, c.tex_of, c.tex_coarse, c.tex_seq) = (Some(refined.view.clone()), here, false, refined.seq);
assert!(!shows(&c, &preview, here));
// Once the view asked for moves on, the preview is the better match.
c.want_view = Some(far.view.clone());
assert!(shows(&c, &preview, here));
// Over another preview, or a refined image of another page, it goes on.
c.want_view = Some(near.view.clone());
c.tex_coarse = true;
assert!(shows(&c, &preview, here));
(c.tex_coarse, c.tex_of) = (false, Some((ds.uid, NodeId(ds.page.0 + 1))));
assert!(shows(&c, &preview, here));
// Never over the refined image of its own request or a newer one (the watchdog's preview can
// come after the refined image), even once the view asked for moved on.
(c.tex_of, c.want_view) = (here, Some(far.view.clone()));
for seq in [preview.seq, preview.seq + 1] {
c.tex_seq = seq;
assert!(!shows(&c, &preview, here), "refined image of request {seq}");
}
}
#[test]
fn a_poll_takes_the_newest_request_and_of_one_request_the_refined_image() {
let (s, _) = document();
let ds = s.ds().unwrap();
let v = job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 0.5, 64, 48));
let preview = |seq| Done { seq, ..preview_with(&v, &mut Retained::default()).unwrap() };
let refined = |seq| Done { seq, ..render_now(&v).unwrap() };
let pick = |order: Vec<Done>| order.into_iter().fold(None, |best, d| Some(better(best, d))).map(|d| (d.seq, d.coarse));
assert_eq!(pick(vec![refined(3), preview(4)]), Some((4, true)), "a newer request's preview over an older refined image");
assert_eq!(pick(vec![preview(3), refined(3)]), Some((3, false)));
assert_eq!(pick(vec![refined(3), preview(3)]), Some((3, false)), "the watchdog's preview after its refined image");
assert_eq!(pick(vec![refined(4), preview(4), preview(3)]), Some((4, false)));
assert_eq!(pick(vec![preview(4)]), Some((4, true)));
}
#[test]
fn renders_from_scratch_with_nothing_to_go_by_get_a_late_preview() {
let (mut s, _) = document();
let (doc, page, uid) = {
let ds = s.ds().unwrap();
(ds.doc.clone(), ds.page, ds.uid)
};
let at = |doc: &Arc<Document>, page, uid, scale| job(doc, page, uid, view_at((300.0, 200.0), scale, 200, 150));
// Renders that have been quick: nothing up front, a preview only should one run long.
let mut r = Renders::with_threshold(f64::INFINITY);
let first = at(&doc, page, uid, 1.0);
assert!(r.wants_late_preview(&first) && r.preview(&first).is_none(), "the first render");
r.refine(&first).unwrap();
assert!(r.wants_late_preview(&at(&doc, page, uid, 4.0)), "a zoom after quick renders");
assert!(r.wants_late_preview(&at(&doc, page, uid + 1, 1.0)), "another file");
let mut panned = first.clone();
panned.view.origin.0 += 5.0;
assert!(!r.wants_late_preview(&panned), "a pan builds on the kept image");
let mut pixels = at(&doc, page, uid, 4.0);
pixels.zoom_preview = false;
assert!(!r.wants_late_preview(&pixels), "pixel preview");
s.execute("page.add", &json!({})).unwrap();
let ds = s.ds().unwrap();
assert!(r.wants_late_preview(&at(&ds.doc, ds.page, uid, 1.0)), "another page");
// Renders that have been slow: the preview comes first instead.
let mut slow = Renders::with_threshold(0.0);
slow.refine(&first).unwrap();
let zoom = at(&doc, page, uid, 4.0);
assert!(!slow.wants_late_preview(&zoom) && slow.preview(&zoom).is_some());
}
/// Every image `w` hands out until it has nothing left in flight: (request, coarse).
fn drain(w: &mut Worker) -> Vec<(u64, bool)> {
let start = std::time::Instant::now();
let mut got = vec![];
while w.in_flight() || got.is_empty() {
assert!(start.elapsed() < std::time::Duration::from_secs(60), "the render never finished");
if let Some(d) = w.poll() {
got.push((d.seq, d.coarse));
}
std::thread::sleep(std::time::Duration::from_millis(1));
}
got.extend(w.poll().map(|d| (d.seq, d.coarse)));
got
}
#[test]
fn a_slow_first_render_gets_a_preview_beside_it_and_a_quick_one_none() {
// Slow: a render from scratch that runs past the threshold, then the preview, with as much
// again to spare, so the preview comes first however fast this machine and the renderer are.
let view = view_at((300.0, 200.0), 2.0, 1200, 1200);
let mut want = 4.0 * PREVIEW_AFTER_MS;
let slow = loop {
let s = slow_scene(std::slice::from_ref(&view), want);
let ds = s.ds().unwrap();
let slow = job(&ds.doc, ds.page, ds.uid, view.clone());
let (full, preview) = (render_now(&slow).unwrap().ms, preview_with(&slow, &mut Retained::default()).unwrap().ms);
if full >= 2.0 * (PREVIEW_AFTER_MS + preview) {
break slow;
}
assert!(want < 64.0 * PREVIEW_AFTER_MS, "previews keep up with full renders: {preview} ms of {full} ms");
want *= 2.0;
};
let mut w = Worker::new(egui::Context::default());
w.submit(slow);
assert_eq!(drain(&mut w), [(1, true), (1, false)], "the preview while it renders, then the refined image");
// Quick: a small view of a few shapes on a fresh worker (the slow render above would make the
// next zoom get its preview first).
let (s, _) = document();
let ds = s.ds().unwrap();
let mut w = Worker::new(egui::Context::default());
w.submit(job(&ds.doc, ds.page, ds.uid, view_at((300.0, 200.0), 0.5, 120, 90)));
assert_eq!(drain(&mut w), [(1, false)], "done before the threshold: no preview");
}
#[test]
fn the_render_thread_refines_a_zoom_only_once_it_pauses() {
// A full render can't be stopped: a zoom step's started as soon as its preview was out held the
// next step up for as long as it took. The next step coming while the preview shows skips it.
let views: Vec<View> = [1.0, 0.5, 0.25].into_iter().map(|s| view_at((300.0, 200.0), s, 1200, 1200)).collect();
let s = slow_scene(&views, 4.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let at = |i: usize| job(&ds.doc, ds.page, ds.uid, views[i].clone());
let mut w = Worker::new(egui::Context::default());
w.submit(at(0));
drain(&mut w);
// A zoom out: its preview, then the next step while that preview is on screen.
w.submit(at(1));
let start = std::time::Instant::now();
let preview = loop {
assert!(start.elapsed() < Duration::from_secs(60), "no preview came");
if let Some(d) = w.poll() {
break d;
}
std::thread::sleep(Duration::from_millis(1));
};
assert_eq!((preview.seq, preview.coarse), (2, true));
w.submit(at(2));
let got = drain(&mut w);
assert!(!got.contains(&(2, false)), "the step zoomed past is never refined: {got:?}");
assert_eq!(got.last(), Some(&(3, false)), "the last step is: {got:?}");
}
#[test]
fn a_preview_replaces_a_refined_image_of_the_same_zoom_elsewhere_on_the_page() {
// 800 × 600: A at 100% from the page origin, B at 800% about its top-left, A' back at 100%
// about B's bottom-right corner. A shows 100 × 75 of A', 1/64 of it.
let (s, _) = document();
let ds = s.ds().unwrap();
let here = Some((ds.uid, ds.page));
let view = |origin, scale| View { origin, scale, width: 800, height: 600 };
let a = job(&ds.doc, ds.page, ds.uid, view((0.0, 0.0), 1.0));
let b = job(&ds.doc, ds.page, ds.uid, view((0.0, 0.0), 8.0));
let a2 = job(&ds.doc, ds.page, ds.uid, view((-700.0, -525.0), 1.0));
let mut r = Renders::with_threshold(0.0);
let refined_a = Done { seq: 1, ..r.refine(&a).unwrap() };
// The canvas shows A; B is asked for, then A' while B renders. The thread finishes B, then
// previews A' before the canvas polls: the queue holds [refined B, preview A'], and a poll
// takes the newer request's.
let queue = [Done { seq: 2, ..r.refine(&b).unwrap() }, Done { seq: 3, ..r.preview(&a2).expect("A' is a new zoom for the thread") }];
let polled = &queue.into_iter().fold(None, |best, d| Some(better(best, d))).unwrap();
assert!(polled.coarse && covers(&polled.view, &a2.view));
let c = CanvasState {
tex_view: Some(refined_a.view.clone()),
tex_of: here,
tex_coarse: false,
tex_seq: refined_a.seq,
want_view: Some(a2.view.clone()),
..Default::default()
};
assert!(shows(&c, polled, here), "A at the same zoom shows 1/64 of A': the preview of all of it goes on");
// Once A' itself is refined on screen, a preview of it would be a step down.
let refined_a2 = r.refine(&a2).unwrap();
let c = CanvasState { tex_view: Some(refined_a2.view.clone()), tex_seq: 3, ..c };
assert!(!shows(&c, polled, here));
}
#[test]
fn the_browser_worker_previews_by_measured_render_time_then_refines_the_next_frame() {
let view = |scale| view_at((300.0, 200.0), scale, 1200, 1200);
let s = slow_scene(&[view(2.0), view(1.0)], 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let at = |scale| job(&ds.doc, ds.page, ds.uid, view(scale));
// Previewing once renders from scratch have taken any time at all: a render the worker didn't
// time (0 ms) gives none. (The production threshold against this scene's speed would hang on
// how busy the machine is when it runs.) Refined the next frame (settling: below).
let mut w = Inline::with_settle(egui::Context::default(), Duration::ZERO).with_threshold(1e-9);
w.submit(at(2.0));
let first = refined(&mut w).expect("the first image");
assert!(!first.coarse && !w.in_flight(), "the first render has no measure to preview by");
assert!(first.ms > 0.0, "renders are timed in the browser worker too: {} ms", first.ms);
// A new zoom: the preview this frame, the refined image over the next (a band each).
w.submit(at(1.0));
let p = w.poll().expect("a preview");
assert!(p.coarse && w.in_flight());
let d = refined(&mut w).expect("the refined image");
assert!(!d.coarse && !w.in_flight());
assert!(close_pixels(&d, &render_now(&at(1.0)).unwrap()), "drawn band by band");
// A newer request before the refinement: refining the old one is skipped.
w.submit(at(0.5));
assert!(w.poll().is_some_and(|d| d.coarse));
w.submit(at(0.25));
let p = w.poll().expect("the newer one's preview");
assert!(p.coarse && (p.view.scale - 0.25 / PREVIEW_FACTOR).abs() < 1e-12);
assert!(refined(&mut w).is_some_and(|d| !d.coarse && d.view.scale == 0.25));
assert!(w.poll().is_none() && !w.in_flight());
}
/// The browser's worker waiting `settle` after a preview, and previewing every render from scratch
/// after the first: what its wait tests check can't hang on how fast this machine renders.
fn waiting(settle: Duration) -> Inline {
Inline::with_settle(egui::Context::default(), settle).with_threshold(0.0)
}
#[test]
fn the_browser_worker_refines_a_zoom_only_once_it_settles() {
let view = |scale| view_at((300.0, 200.0), scale, 1200, 1200);
let s = document().0;
let ds = s.ds().unwrap();
let at = |scale| job(&ds.doc, ds.page, ds.uid, view(scale));
let settle = Duration::from_millis(SETTLE_MS);
let mut w = waiting(settle);
w.submit(at(2.0));
assert!(refined(&mut w).is_some_and(|d| !d.coarse), "the first render: no preview, no wait");
// Zooming: each step shows its preview, never a full render in between.
let now = Instant::now();
for scale in [1.5, 1.0] {
w.submit(at(scale));
assert!(w.poll_at(now).is_some_and(|d| d.coarse));
assert!(w.poll_at(now).is_none() && w.in_flight(), "not refined while the zoom may go on");
}
let d = refined_at(&mut w, now + settle).expect("refined once it settled");
assert!(!d.coarse && d.view.scale == 1.0 && !w.in_flight());
// A pan at the same zoom has no preview and is refined at once.
w.submit(job(&ds.doc, ds.page, ds.uid, view_at((340.0, 200.0), 1.0, 1200, 1200)));
assert!(refined(&mut w).is_some_and(|d| !d.coarse));
}
/// The wait counts from the preview being shown, not from the request: rendering the preview can
/// take longer than the wait (the page is blocked meanwhile, so no newer request could come), and
/// counted from the request the refinement would follow in the very next frame. The time the
/// preview's render would take is stood in for by polling that much after the request.
#[test]
fn the_wait_counts_from_the_preview_not_from_the_request() {
let view = |scale| view_at((300.0, 200.0), scale, 1200, 1200);
let s = document().0;
let ds = s.ds().unwrap();
let at = |scale| job(&ds.doc, ds.page, ds.uid, view(scale));
let settle = Duration::from_millis(SETTLE_MS);
let mut w = waiting(settle);
w.submit(at(2.0));
assert!(refined(&mut w).is_some_and(|d| !d.coarse));
let asked = at(1.0);
let shown = asked.at + settle + Duration::from_millis(30);
w.submit(asked);
assert!(w.poll_at(shown).is_some_and(|d| d.coarse), "the preview, longer after the request than the wait");
assert!(w.poll_at(shown).is_none() && w.in_flight(), "the wait starts only now");
assert!(refined_at(&mut w, shown + settle).is_some_and(|d| !d.coarse && d.view.scale == 1.0));
}
/// Until the zoom's full render has run, the kept image is of the old zoom, so a pan or an edit
/// at the new zoom renders from scratch too: it shows a preview and restarts the wait rather than
/// running a full render between it and the next step. Once refined, requests at that zoom build
/// on the kept image: no preview, no wait.
#[test]
fn same_zoom_requests_before_the_zoom_refines_keep_waiting_and_refine_at_once_after() {
let view = |c, scale| view_at(c, scale, 1200, 1200);
let s = document().0;
let ds = s.ds().unwrap();
let at = |c, scale| job(&ds.doc, ds.page, ds.uid, view(c, scale));
let settle = Duration::from_millis(SETTLE_MS);
let mut w = waiting(settle);
w.submit(at((300.0, 200.0), 2.0));
assert!(refined(&mut w).is_some_and(|d| !d.coarse), "the first render: no preview, no wait");
// A zoom step, then a pan at the new zoom before the pause: a preview each, no full render.
let now = Instant::now();
w.submit(at((300.0, 200.0), 1.0));
assert!(w.poll_at(now).is_some_and(|d| d.coarse));
assert!(w.poll_at(now).is_none() && w.in_flight());
w.submit(at((340.0, 200.0), 1.0));
assert!(w.poll_at(now).is_some_and(|d| d.coarse), "from scratch still: the kept image is of the old zoom");
assert!(w.poll_at(now).is_none() && w.in_flight(), "the wait starts over");
let d = refined_at(&mut w, now + settle).expect("refined once it settled");
assert!(!d.coarse && d.view.scale == 1.0 && !w.in_flight());
// From then on a pan at this zoom builds on the kept image: no preview, refined at once.
w.submit(at((380.0, 200.0), 1.0));
let d = refined(&mut w).expect("the refined image");
assert!(!d.coarse && !w.in_flight());
}
/// The wait never costs more than the full render it may save: a preview is refined once the
/// last full render's time has passed when that is shorter than `SETTLE_MS`, so a key zoom or a
/// page switch on a page whose renders are quick is not held coarse for longer than before.
#[test]
fn the_wait_is_capped_by_the_time_of_the_last_full_render() {
let view = |scale| view_at((300.0, 200.0), scale, 1200, 1200);
let s = document().0;
let ds = s.ds().unwrap();
let at = |scale| job(&ds.doc, ds.page, ds.uid, view(scale));
// A settle far longer than this page's renders: the wait is their time instead.
let settle = Duration::from_secs(10);
let mut w = waiting(settle);
w.submit(at(2.0));
let first = refined(&mut w).expect("the first image");
assert!(!first.coarse);
let full = Duration::from_secs_f64(first.ms / 1000.0);
assert!(full < settle, "the cap is what this checks: {} ms", first.ms);
let now = Instant::now();
w.submit(at(1.0));
assert!(w.poll_at(now).is_some_and(|d| d.coarse));
assert!(w.poll_at(now).is_none() && w.in_flight(), "not refined in the very next frame");
assert!(w.poll_at(now + full * 9 / 10).is_none() && w.in_flight(), "nor just before that time");
let d = refined_at(&mut w, now + full).expect("refined once the last full render's time has passed, not the settle");
assert!(!d.coarse && d.view.scale == 1.0 && !w.in_flight());
}
#[test]
fn the_browser_draws_a_full_render_band_by_band() {
let view = |x| view_at((x, 200.0), 1.0, 600, 600);
let s = slow_scene(&[view(300.0)], 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let at = |x| job(&ds.doc, ds.page, ds.uid, view(x));
let mut r = Renders::default();
let (d, n) = stepped(&mut r, &at(300.0));
let d = d.expect("drawn");
assert!(n > 2 && !r.stepping(), "several calls, then done ({n})");
assert!(close_pixels(&d, &render_now(&at(300.0)).unwrap()));
// Kept: a pan now patches it at once.
assert!(matches!(r.refine_for(&at(320.0), 0.0), Refined::Done(Some(d)) if d.work != Work::Full));
}
#[test]
fn a_pan_while_drawing_finishes_the_render_then_patches_it_and_a_zoom_drops_it() {
let view = |x, scale| view_at((x, 200.0), scale, 600, 600);
let s = slow_scene(&[view(300.0, 1.0)], 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let at = |x, scale| job(&ds.doc, ds.page, ds.uid, view(x, scale));
let mut r = Renders::default();
assert!(matches!(r.refine_for(&at(300.0, 1.0), 0.0), Refined::More));
// Panned meanwhile: the same render goes on, and what comes is the panned view.
let (d, _) = stepped(&mut r, &at(330.0, 1.0));
let d = d.expect("drawn");
assert!(close_pixels(&d, &render_now(&at(330.0, 1.0)).unwrap()), "the panned view");
// Zoomed meanwhile: the render under way is dropped for one of the new zoom.
let mut r = Renders::default();
assert!(matches!(r.refine_for(&at(300.0, 1.0), 0.0), Refined::More));
let (d, _) = stepped(&mut r, &at(300.0, 2.0));
assert_eq!(d.expect("drawn").view.scale, 2.0);
}
#[test]
fn an_edit_while_drawing_shows_in_what_comes() {
let v = view_at((300.0, 200.0), 1.0, 600, 600);
let mut s = slow_scene(std::slice::from_ref(&v), 3.0 * PREVIEW_AFTER_MS);
let (doc, page, uid) = {
let ds = s.ds().unwrap();
(ds.doc.clone(), ds.page, ds.uid)
};
let mut r = Renders::default();
assert!(matches!(r.refine_for(&job(&doc, page, uid, v.clone()), 0.0), Refined::More));
// Edited meanwhile, the view unchanged: the render goes on and what comes shows the edit.
s.execute("shape.rectangle", &json!({"x": 100, "y": 0, "width": 400, "height": 400})).unwrap();
let edited = job(&s.ds().unwrap().doc, page, uid, v);
let (d, _) = stepped(&mut r, &edited);
assert!(close_pixels(&d.expect("drawn"), &render_now(&edited).unwrap()), "the edit shows");
}
#[test]
fn a_render_overtaken_by_a_long_pan_is_shown_then_drawn_again() {
let v = view_at((300.0, 200.0), 1.0, 600, 600);
let s = slow_scene(std::slice::from_ref(&v), 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let mut r = Renders::default();
assert!(matches!(r.refine_for(&job(&ds.doc, ds.page, ds.uid, v.clone()), 0.0), Refined::More));
// Panned more than a view meanwhile: nothing to patch. What was drawn shows, then the new view.
let far = job(&ds.doc, ds.page, ds.uid, view_at((1500.0, 200.0), 1.0, 600, 600));
let mut shown = vec![];
let last = (0..1000).find_map(|_| match r.refine_for(&far, 0.0) {
Refined::More => None,
Refined::Shown(d) => {
shown.push(d);
None
}
Refined::Done(d) => Some(d),
});
assert_eq!(shown.len(), 1, "the render drawn shows once");
assert!(close_pixels(&shown[0], &render_now(&job(&ds.doc, ds.page, ds.uid, v)).unwrap()), "the view it was drawn for");
assert!(close_pixels(&last.flatten().expect("drawn"), &render_now(&far).unwrap()), "then the new view");
}
/// Drawn for the very request, the render is done: it is not started on again, even where the
/// kept image can never be patched (outline mode drawing hidden layers), which drew it again
/// and again, the page never idle.
#[test]
fn a_render_drawn_for_the_request_is_done_even_where_it_could_never_be_patched() {
let v = view_at((300.0, 200.0), 1.0, 600, 600);
let s = slow_scene(std::slice::from_ref(&v), 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let mut hidden = job(&ds.doc, ds.page, ds.uid, v);
hidden.outline = true;
hidden.outline_extras.hidden = true;
let mut r = Renders::default();
let (d, n) = stepped(&mut r, &hidden);
assert!(d.is_some_and(|d| !d.coarse && d.work == Work::Full) && !r.stepping(), "done after {n} calls");
assert!(n < 100, "drawn once, not over and over ({n} calls)");
}
/// A change of render options (outline mode here) mid-way drops the render, as a zoom does: the
/// bands of the old one are not drawn to the end first.
#[test]
fn a_change_of_options_while_drawing_drops_the_render() {
let v = view_at((300.0, 200.0), 1.0, 600, 600);
let s = slow_scene(std::slice::from_ref(&v), 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let plain = job(&ds.doc, ds.page, ds.uid, v.clone());
let mut outlined = plain.clone();
outlined.outline = true;
let (_, alone) = stepped(&mut Renders::default(), &outlined);
let mut r = Renders::default();
assert!(matches!(r.refine_for(&plain, 0.0), Refined::More));
let (d, n) = stepped(&mut r, &outlined);
assert!(d.is_some_and(|d| !d.coarse));
assert!(n <= alone + 1, "the old render's bands are dropped: {n} calls against {alone} alone");
}
/// A render dropped mid-way leaves a measure behind: what its bands took is at least what a full
/// render takes, so the next zoom gets its preview (and, in the browser, its wait) instead of
/// starting from scratch at once, as many times as the zoom goes on.
#[test]
fn a_render_dropped_while_drawing_leaves_its_time_as_the_measure() {
let view = |scale| view_at((300.0, 200.0), scale, 600, 600);
let s = slow_scene(&[view(1.0)], 3.0 * PREVIEW_AFTER_MS);
let ds = s.ds().unwrap();
let at = |scale| job(&ds.doc, ds.page, ds.uid, view(scale));
// Previews once renders have taken any time at all: a band has, where no measure (0 ms) hasn't.
let mut r = Renders::with_threshold(1e-9);
assert!(matches!(r.refine_for(&at(1.0), 0.0), Refined::More));
assert!(r.preview(&at(2.0)).is_some(), "the zoom gets a preview by the dropped render's measure");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.