use std::time::Duration;
use super::{tests::device, *};
use crate::{
canvas::test_pages::{CHARGE, IMAGE_BYTES, SHAPE_BUDGET, draw_cell, draw_label, images, labels, pixel, replacement},
images::ImageData,
node::transform::Transform2D,
};
fn encode(canvas: &CanvasHandle, renderer: &mut Renderer, gpu: &(Device, Queue)) -> u64 {
let before = canvas.status().gpu.uploaded_bytes;
renderer.process(&gpu.0, &gpu.1, std::slice::from_ref(canvas));
gpu.0.poll(PollType::wait_indefinitely()).unwrap();
canvas.status().gpu.uploaded_bytes - before
}
fn take(canvas: &CanvasHandle, renderer: &mut Renderer, gpu: &(Device, Queue)) -> CanvasSnapshot {
let read = canvas.snapshot();
encode(canvas, renderer, gpu);
read.wait_timeout(Duration::from_secs(15)).unwrap().unwrap()
}
#[test]
#[ignore = "requires a GPU adapter; run explicitly and separately from context-creation tests"]
fn gpu_replacement_drawn_in_batches_is_one_cache_frame_and_artwork_passes_age_nothing() {
let gpu = device();
let mut renderer = Renderer::new(&gpu.0, &gpu.1).with_asset_budget(CanvasAssetBudget::new(16 * CHARGE));
let canvas = CanvasHandle::test_surface(64, 64, 1., false);
let page = images(24, 0);
let draw_page = |renderer: &mut Renderer| {
replacement(
&canvas,
page.len(),
3,
|d, at| draw_cell(d, &page[at], at),
|| encode(&canvas, renderer, &gpu),
)
};
let uploads: Vec<_> = (0..3).map(|_| draw_page(&mut renderer)).collect();
assert_eq!(canvas.status().error, None);
assert_eq!(
uploads,
[24 * IMAGE_BYTES, 0, 0],
"a later batch evicted textures an earlier batch of the same page drew"
);
assert_eq!(renderer.assets.bytes(), 24 * CHARGE, "the page stretches the cache");
let d = canvas.context_2d();
for shift in 1..6 {
let token = d.begin_presentation().unwrap();
d.reset();
d.draw_retained_artwork(Transform2D::translate(shift as f32, 0.))
.unwrap();
d.commit_presentation(token).unwrap();
assert_eq!(encode(&canvas, &mut renderer, &gpu), 0);
}
assert_eq!(
draw_page(&mut renderer),
0,
"artwork passes aged the page out of the cache"
);
assert_eq!(canvas.status().error, None);
}
#[test]
#[ignore = "requires a GPU adapter; run explicitly and separately from context-creation tests"]
fn gpu_labels_of_a_replacement_drawn_in_batches_are_shaped_once() {
let gpu = device();
let mut renderer = Renderer::new(&gpu.0, &gpu.1);
let canvas = CanvasHandle::test_surface(512, 512, 1., false);
let labels = labels();
let mut draw_page = || {
replacement(
&canvas,
labels.len(),
3,
|d, at| draw_label(d, &labels, at),
|| encode(&canvas, &mut renderer, &gpu),
)
};
let warm = [draw_page(), draw_page()];
let shaped = canvas.shaped_text_bytes();
assert!(
(SHAPE_BUDGET + 1..=2 * SHAPE_BUDGET).contains(&shaped),
"the page is charged {shaped} bytes"
);
let steady = [draw_page(), draw_page()];
assert_eq!(canvas.status().error, None);
assert!(warm[0] > 0);
assert_eq!(steady, [0, 0], "labels of the previous replacement were shaped again");
}
#[test]
#[ignore = "requires a GPU adapter; run explicitly and separately from context-creation tests"]
fn gpu_retained_front_outlives_every_texture_it_was_drawn_from() {
let gpu = device();
let mut renderer = Renderer::new(&gpu.0, &gpu.1).with_asset_budget(CanvasAssetBudget::new(2 * CHARGE));
let canvas = CanvasHandle::test_surface(64, 64, 1., false);
let d = canvas.context_2d();
let red = ImageData::from_rgba([255, 0, 0, 255].repeat(16 * 16), 16, 16);
let blue = ImageData::from_rgba([0, 0, 255, 255].repeat(16 * 16), 16, 16);
let draw_front = || {
d.reset();
d.draw_image_scaled(&red, 0., 0., 64., 64.).unwrap();
d.draw_image_scaled(&blue, 0., 0., 16., 64.).unwrap();
};
let front = d.begin_presentation().unwrap();
draw_front();
d.capture_artwork().unwrap();
d.commit_presentation(front).unwrap();
assert_eq!(encode(&canvas, &mut renderer, &gpu), 2 * IMAGE_BYTES);
let shown = take(&canvas, &mut renderer, &gpu);
assert_eq!(pixel(&shown, 4, 4), [0, 0, 255, 255]);
assert_eq!(pixel(&shown, 40, 4), [255, 0, 0, 255]);
for salt in 1..5 {
d.begin_presentation().unwrap();
d.reset();
for (at, image) in images(4, salt).iter().enumerate() {
draw_cell(&d, image, at);
}
encode(&canvas, &mut renderer, &gpu);
}
assert!(renderer.assets.bytes() <= 4 * CHARGE);
let pending = take(&canvas, &mut renderer, &gpu);
assert_eq!(
(&pending.rgba, pending.revision),
(&shown.rgba, shown.revision),
"the pending replacement must not change the completed front"
);
let token = d.begin_presentation().unwrap();
d.reset();
d.draw_retained_artwork(Transform2D::translate(0., 0.)).unwrap();
d.commit_presentation(token).unwrap();
assert_eq!(encode(&canvas, &mut renderer, &gpu), 0);
let reprojected = take(&canvas, &mut renderer, &gpu);
for (x, y) in [(4, 4), (8, 60), (40, 4), (60, 60)] {
assert_eq!(pixel(&reprojected, x, y), pixel(&shown, x, y));
}
let token = d.begin_presentation().unwrap();
draw_front();
d.commit_presentation(token).unwrap();
assert_eq!(encode(&canvas, &mut renderer, &gpu), 2 * IMAGE_BYTES);
assert_eq!(canvas.status().error, None);
}