683 lines
24 KiB
Rust
683 lines
24 KiB
Rust
use deckstride::{
|
|
output::{HostState, coalesce},
|
|
settings::Settings,
|
|
zoom::{PerformanceWatch, Sync, View},
|
|
};
|
|
use egui::{Context, Pos2, RawInput, Rect, TextureOptions, Vec2};
|
|
use egui_software_backend::{BufferMutRef, ColorFieldOrder, EguiSoftwareRender};
|
|
use std::time::{Duration, Instant};
|
|
#[test]
|
|
fn crop_anchor_pan_and_limits() {
|
|
let start = View::default();
|
|
let zoom = start.zoom_at(2., [0.25, 0.75]);
|
|
assert_eq!(zoom.center, [0.375, 0.625]);
|
|
assert_eq!(zoom.uv().size(), Vec2::splat(0.5));
|
|
let panned = zoom.pan([0.1, -0.1]);
|
|
assert!((panned.center[0] - 0.325).abs() < 0.00001);
|
|
let edge = panned.pan([100., -100.]);
|
|
assert_eq!(edge.center, [0.25, 0.75]);
|
|
assert_eq!(edge.zoom_at(1., [0., 0.]), start);
|
|
assert_eq!(start.zoom_at(100., [0.5; 2]).scale, 8.);
|
|
assert_eq!(
|
|
View {
|
|
scale: f32::NAN,
|
|
center: [f32::INFINITY, 0.]
|
|
}
|
|
.normalized(),
|
|
start
|
|
);
|
|
assert_eq!(start.pan([f32::NAN, f32::INFINITY]), start);
|
|
}
|
|
#[test]
|
|
fn synchronization_rejects_stale_gestures_and_coalesces_without_losing_frames() {
|
|
let mut presenter = Sync::default();
|
|
presenter.set(true, View::default());
|
|
let mut host = presenter;
|
|
host.gesture(host.view.zoom_at(3., [0.5; 2]));
|
|
let old = host;
|
|
host.gesture(host.view.pan([0.1, 0.]));
|
|
assert!(presenter.accept_output(host));
|
|
assert!(!presenter.accept_output(old));
|
|
host.accept_presenter(old);
|
|
assert_eq!(host, presenter);
|
|
presenter.set(true, View::default());
|
|
assert!(!presenter.accept_output(host));
|
|
host.accept_presenter(presenter);
|
|
assert_eq!(host.view, View::default());
|
|
presenter.set(false, host.view.zoom_at(4., [0.5; 2]));
|
|
assert_eq!(presenter.view, View::default());
|
|
let mut pending = Some(HostState {
|
|
generation: 4,
|
|
page: 2,
|
|
sequence: 12,
|
|
monitors: vec!["screen".into()],
|
|
zoom: host,
|
|
..Default::default()
|
|
});
|
|
host.gesture(host.view.zoom_at(4., [0.5; 2]));
|
|
coalesce(
|
|
&mut pending,
|
|
HostState {
|
|
zoom_only: true,
|
|
zoom: host,
|
|
generation: 4,
|
|
page: 2,
|
|
..Default::default()
|
|
},
|
|
);
|
|
let state = pending.as_ref().unwrap();
|
|
assert_eq!(state.monitors, vec!["screen"]);
|
|
assert_eq!(state.sequence, 12);
|
|
assert!(!state.zoom_only);
|
|
assert_eq!(state.zoom, host);
|
|
coalesce(
|
|
&mut pending,
|
|
HostState {
|
|
zoom_only: true,
|
|
generation: 3,
|
|
..Default::default()
|
|
},
|
|
);
|
|
assert_eq!(pending.as_ref().unwrap().zoom, host);
|
|
coalesce(
|
|
&mut pending,
|
|
HostState {
|
|
quit: true,
|
|
..Default::default()
|
|
},
|
|
);
|
|
assert!(pending.unwrap().quit);
|
|
}
|
|
#[test]
|
|
fn settings_default_opt_out_roundtrip_and_warning_threshold() {
|
|
assert!(!Settings::default().zoom_enabled);
|
|
let old: Settings = toml::from_str("version=1").unwrap();
|
|
assert!(!old.zoom_enabled);
|
|
assert!(!old.zoom_keep_fitted_area);
|
|
assert!(!Settings::default().zoom_keep_fitted_area);
|
|
let enabled = Settings {
|
|
zoom_enabled: true,
|
|
zoom_keep_fitted_area: true,
|
|
..Default::default()
|
|
};
|
|
let restored: Settings = toml::from_str(&toml::to_string(&enabled).unwrap()).unwrap();
|
|
assert!(restored.zoom_enabled);
|
|
assert!(restored.zoom_keep_fitted_area);
|
|
let mut watch = PerformanceWatch::default();
|
|
assert!(!watch.observe(false, Duration::from_secs(1)));
|
|
assert!(!watch.observe(true, Duration::from_millis(40)));
|
|
assert!(!watch.observe(true, Duration::from_millis(40)));
|
|
assert!(watch.observe(true, Duration::from_millis(40)));
|
|
assert!(!watch.observe(true, Duration::from_millis(20)));
|
|
assert!(!watch.observe(true, Duration::from_millis(40)));
|
|
}
|
|
#[test]
|
|
fn zoom_paints_existing_texture_crop_with_constant_geometry_and_no_new_uploads() {
|
|
let ctx = Context::default();
|
|
let mut rgba = vec![0; 64 * 32 * 4];
|
|
for y in 0..32 {
|
|
for x in 0..64 {
|
|
let color = if x < 32 {
|
|
[255, 0, 0, 255]
|
|
} else {
|
|
[0, 0, 255, 255]
|
|
};
|
|
rgba[(y * 64 + x) * 4..(y * 64 + x + 1) * 4].copy_from_slice(&color);
|
|
}
|
|
}
|
|
let texture = ctx.load_texture(
|
|
"slide",
|
|
egui::ColorImage::from_rgba_unmultiplied([64, 32], &rgba),
|
|
TextureOptions::NEAREST,
|
|
);
|
|
let mut renderer = EguiSoftwareRender::new(ColorFieldOrder::Bgra);
|
|
let rect = Rect::from_min_size(Pos2::ZERO, Vec2::splat(200.));
|
|
let mut pixels = vec![0u32; 200 * 200];
|
|
for (index, view) in [
|
|
View::default(),
|
|
View {
|
|
scale: 2.,
|
|
center: [0.25, 0.5],
|
|
},
|
|
View {
|
|
scale: 2.,
|
|
center: [0.75, 0.5],
|
|
},
|
|
]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
let output = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(rect),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
deckstride::presenter_ui::paint_slide_zoomed(
|
|
ui.painter(),
|
|
rect,
|
|
texture.id(),
|
|
[64, 32],
|
|
Default::default(),
|
|
view,
|
|
);
|
|
},
|
|
);
|
|
if index > 0 {
|
|
assert!(
|
|
output.textures_delta.set.is_empty(),
|
|
"zoom uploaded another image"
|
|
);
|
|
}
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
for primitive in &primitives {
|
|
if let egui::epaint::Primitive::Mesh(mesh) = &primitive.primitive
|
|
&& mesh.texture_id == texture.id()
|
|
{
|
|
assert!(
|
|
mesh.vertices.iter().all(|v| rect.contains(v.pos)),
|
|
"zoom enlarged draw geometry"
|
|
);
|
|
}
|
|
}
|
|
renderer.render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut pixels), 200, 200),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
assert_eq!(pixels[5 * 200 + 5] & 0xffffff, 0); // Padding unchanged.
|
|
if index > 0 {
|
|
let expected = if index == 1 { 0xff0000 } else { 0x0000ff };
|
|
assert_eq!(pixels[100 * 200 + 30] & 0xffffff, expected);
|
|
assert_eq!(pixels[100 * 200 + 170] & 0xffffff, expected);
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
#[ignore = "Manual Linux software drawing measurement; not a timing-sensitive CI assertion"]
|
|
fn buffered_zoom_drawing_measurement() {
|
|
for [width, height] in [[1920usize, 1080usize], [3840, 2160]] {
|
|
let ctx = Context::default();
|
|
let rgba: Vec<u8> = (0..1920 * 1080)
|
|
.flat_map(|p| [(p % 256) as u8, ((p / 1920) % 256) as u8, 128, 255])
|
|
.collect();
|
|
let texture = ctx.load_texture(
|
|
"benchmark",
|
|
egui::ColorImage::from_rgba_unmultiplied([1920, 1080], &rgba),
|
|
TextureOptions::LINEAR,
|
|
);
|
|
let mut renderer = EguiSoftwareRender::new(ColorFieldOrder::Bgra);
|
|
let mut pixels = vec![0u32; width * height];
|
|
let rect = Rect::from_min_size(Pos2::ZERO, Vec2::new(width as f32, height as f32));
|
|
for scale in [1., 4., 8.] {
|
|
let mut times = Vec::new();
|
|
for i in 0..12 {
|
|
let start = Instant::now();
|
|
let view = View {
|
|
scale,
|
|
center: [0.4 + i as f32 * 0.01, 0.5],
|
|
}
|
|
.normalized();
|
|
let output = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(rect),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
deckstride::presenter_ui::paint_slide_adapted(
|
|
ui.painter(),
|
|
rect,
|
|
texture.id(),
|
|
[210, 297],
|
|
Default::default(),
|
|
Sync {
|
|
enabled: true,
|
|
view,
|
|
..Default::default()
|
|
},
|
|
);
|
|
},
|
|
);
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
renderer.render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut pixels), width, height),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
if i > 1 {
|
|
times.push(start.elapsed().as_secs_f64() * 1000.);
|
|
}
|
|
}
|
|
times.sort_by(f64::total_cmp);
|
|
println!(
|
|
"{width}x{height} {scale}x: median {:.2} ms, max {:.2} ms",
|
|
times[times.len() / 2],
|
|
times.last().unwrap()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn wheel_drag_and_double_click_operate_in_slide_coordinates() {
|
|
let ctx = Context::default();
|
|
let target = Rect::from_min_max(Pos2::new(40., 40.), Pos2::new(440., 240.));
|
|
let mut view = View::default();
|
|
let mut time = 0.;
|
|
let mut render = |events: Vec<egui::Event>| {
|
|
time += 0.04;
|
|
let _ = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(500., 300.))),
|
|
events,
|
|
time: Some(time),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
view = deckstride::presenter_ui::zoom_gestures(ui, target, view).0;
|
|
},
|
|
);
|
|
view
|
|
};
|
|
let center = target.center();
|
|
render(vec![egui::Event::PointerMoved(center)]);
|
|
render(vec![egui::Event::MouseWheel {
|
|
unit: egui::MouseWheelUnit::Point,
|
|
phase: egui::TouchPhase::Move,
|
|
delta: Vec2::new(0., 300.),
|
|
modifiers: egui::Modifiers::NONE,
|
|
}]);
|
|
let mut zoom = View::default();
|
|
for _ in 0..30 {
|
|
zoom = render(vec![]);
|
|
}
|
|
assert!(zoom.scale > 1.2);
|
|
let click = |pos, pressed| egui::Event::PointerButton {
|
|
pos,
|
|
button: egui::PointerButton::Primary,
|
|
pressed,
|
|
modifiers: egui::Modifiers::NONE,
|
|
};
|
|
render(vec![click(center, true)]);
|
|
let moved = center + Vec2::new(40., 10.);
|
|
let panned = render(vec![egui::Event::PointerMoved(moved)]);
|
|
assert!(panned.center[0] < zoom.center[0]);
|
|
render(vec![click(moved, false)]);
|
|
for _ in 0..20 {
|
|
render(vec![]);
|
|
}
|
|
for _ in 0..2 {
|
|
render(vec![click(moved, true)]);
|
|
zoom = render(vec![click(moved, false)]);
|
|
}
|
|
assert_eq!(zoom, View::default());
|
|
}
|
|
|
|
#[test]
|
|
fn optimized_crop_matches_general_renderer_with_alpha_clipping_and_dpi() {
|
|
for dpi in [1., 2.] {
|
|
let ctx = Context::default();
|
|
ctx.set_pixels_per_point(dpi);
|
|
let rgba: Vec<u8> = (0..64 * 32)
|
|
.flat_map(|p| {
|
|
[
|
|
(p % 64 * 4) as u8,
|
|
(p / 64 * 8) as u8,
|
|
80,
|
|
(40 + p % 64 * 3) as u8,
|
|
]
|
|
})
|
|
.collect();
|
|
let texture = ctx.load_texture(
|
|
"alpha",
|
|
egui::ColorImage::from_rgba_unmultiplied([64, 32], &rgba),
|
|
TextureOptions::LINEAR,
|
|
);
|
|
let mut fast = EguiSoftwareRender::new(ColorFieldOrder::Bgra);
|
|
let mut reference =
|
|
EguiSoftwareRender::new(ColorFieldOrder::Bgra).with_allow_raster_opt(false);
|
|
let rect = Rect::from_min_size(Pos2::ZERO, Vec2::new(320., 240.));
|
|
let mut actual = vec![0u32; (320. * dpi) as usize * (240. * dpi) as usize];
|
|
let mut expected = actual.clone();
|
|
for view in [
|
|
View {
|
|
scale: 2.,
|
|
center: [0.25, 0.25],
|
|
},
|
|
View {
|
|
scale: 3.1,
|
|
center: [0.7, 0.4],
|
|
},
|
|
] {
|
|
let output = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(rect),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
let painter = ui.painter().with_clip_rect(rect.shrink(20.));
|
|
deckstride::presenter_ui::paint_slide_zoomed(
|
|
&painter,
|
|
rect,
|
|
texture.id(),
|
|
[64, 32],
|
|
Default::default(),
|
|
view,
|
|
);
|
|
},
|
|
);
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
let width = (320. * output.pixels_per_point) as usize;
|
|
let height = (240. * output.pixels_per_point) as usize;
|
|
// egui applies a requested DPI change on a subsequent frame.
|
|
actual.resize(width * height, 0);
|
|
expected.resize(width * height, 0);
|
|
actual.fill(0);
|
|
expected.fill(0);
|
|
fast.render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut actual), width, height),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
reference.render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut expected), width, height),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
for (a, b) in actual.iter().zip(&expected) {
|
|
for (a, b) in a.to_le_bytes().iter().zip(b.to_le_bytes()) {
|
|
assert!(
|
|
a.abs_diff(b) <= 2,
|
|
"crop pixel mismatch: {a} vs {b} at DPI {dpi}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn parallel_crop_bands_have_no_seams_at_fractional_boundaries() {
|
|
let ctx = Context::default();
|
|
let texture = ctx.load_texture(
|
|
"solid",
|
|
egui::ColorImage::from_rgba_unmultiplied([64, 32], &[255, 180, 60, 255].repeat(64 * 32)),
|
|
TextureOptions::LINEAR,
|
|
);
|
|
let rect = Rect::from_min_size(Pos2::ZERO, Vec2::new(1931., 1087.));
|
|
let output = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(rect),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
deckstride::presenter_ui::paint_slide_zoomed(
|
|
ui.painter(),
|
|
rect,
|
|
texture.id(),
|
|
[64, 32],
|
|
Default::default(),
|
|
View {
|
|
scale: 3.7,
|
|
center: [0.4, 0.6],
|
|
},
|
|
);
|
|
},
|
|
);
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
assert_eq!(primitives.iter().filter(|p| matches!(&p.primitive, egui::epaint::Primitive::Mesh(m) if m.texture_id == texture.id())).count(),4);
|
|
let mut pixels = vec![0u32; 1931 * 1087];
|
|
EguiSoftwareRender::new(ColorFieldOrder::Bgra).render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut pixels), 1931, 1087),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
for y in 62..1025 {
|
|
for x in [50, 965, 1880] {
|
|
assert_eq!(
|
|
pixels[y * 1931 + x] & 0xffffff,
|
|
0xffb43c,
|
|
"band seam at {x},{y}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn portrait_zoom_fills_screen_without_stretching_or_out_of_bounds_pixels() {
|
|
use deckstride::presenter_ui::zoom_geometry;
|
|
for size in [
|
|
Vec2::new(1920., 1080.),
|
|
Vec2::new(1080., 1920.),
|
|
Vec2::new(640., 480.),
|
|
] {
|
|
let rect = Rect::from_min_size(Pos2::new(12., 18.), size);
|
|
for dimensions in [[210, 297], [297, 210]] {
|
|
let (fitted, _) = zoom_geometry(rect, dimensions, View::default(), false);
|
|
for scale in [1., 1.5, 3., 8.] {
|
|
for center in [[0.5; 2], [0.; 2], [1.; 2]] {
|
|
let view = View { scale, center };
|
|
let (target, uv) = zoom_geometry(rect, dimensions, view, false);
|
|
assert!(rect.contains_rect(target));
|
|
assert!(Rect::from_min_max(Pos2::ZERO, Pos2::new(1., 1.)).contains_rect(uv));
|
|
let x_scale = target.width() / (uv.width() * dimensions[0] as f32);
|
|
let y_scale = target.height() / (uv.height() * dimensions[1] as f32);
|
|
assert!((x_scale - y_scale).abs() < 0.001, "page was stretched");
|
|
if scale >= 3. {
|
|
assert_eq!(target, rect);
|
|
}
|
|
assert_eq!(zoom_geometry(rect, dimensions, view, true).0, fitted);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn adapted_portrait_pixels_fill_padding_without_uploading_another_texture() {
|
|
let ctx = Context::default();
|
|
let texture = ctx.load_texture(
|
|
"portrait",
|
|
egui::ColorImage::filled([21, 30], egui::Color32::RED),
|
|
TextureOptions::LINEAR,
|
|
);
|
|
let rect = Rect::from_min_size(Pos2::ZERO, Vec2::new(320., 180.));
|
|
let mut renderer = EguiSoftwareRender::new(ColorFieldOrder::Bgra);
|
|
let mut pixels = vec![0u32; 320 * 180];
|
|
for (index, (scale, keep_fitted_area)) in [(1., false), (3., false), (3., true)]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
let output = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(rect),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
deckstride::presenter_ui::paint_slide_adapted(
|
|
ui.painter(),
|
|
rect,
|
|
texture.id(),
|
|
[21, 30],
|
|
Default::default(),
|
|
Sync {
|
|
enabled: true,
|
|
keep_fitted_area,
|
|
view: View {
|
|
scale,
|
|
center: [0.5; 2],
|
|
},
|
|
..Default::default()
|
|
},
|
|
);
|
|
},
|
|
);
|
|
if index > 0 {
|
|
assert!(output.textures_delta.set.is_empty());
|
|
}
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
renderer.render(
|
|
&mut BufferMutRef::new(bytemuck::cast_slice_mut(&mut pixels), 320, 180),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
let edge = pixels[90 * 320 + 4] & 0xffffff;
|
|
let center = pixels[90 * 320 + 160] & 0xffffff;
|
|
if index == 1 {
|
|
assert_eq!(edge, center);
|
|
} else {
|
|
assert_ne!(edge, center);
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn portrait_screen_adapting_gestures_pan_visible_area_and_reset() {
|
|
let ctx = Context::default();
|
|
let target = Rect::from_min_max(Pos2::new(40., 40.), Pos2::new(440., 240.));
|
|
let mut view = View::default();
|
|
let mut time = 0.;
|
|
let mut render = |events: Vec<egui::Event>| {
|
|
time += 0.04;
|
|
let _ = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(500., 300.))),
|
|
events,
|
|
time: Some(time),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
view =
|
|
deckstride::presenter_ui::zoom_gestures_in(ui, target, [210, 297], view, false)
|
|
.0;
|
|
},
|
|
);
|
|
view
|
|
};
|
|
let center = target.center();
|
|
render(vec![egui::Event::PointerMoved(center)]);
|
|
render(vec![egui::Event::MouseWheel {
|
|
unit: egui::MouseWheelUnit::Point,
|
|
phase: egui::TouchPhase::Move,
|
|
delta: Vec2::new(0., 300.),
|
|
modifiers: egui::Modifiers::NONE,
|
|
}]);
|
|
let mut zoom = View::default();
|
|
for _ in 0..30 {
|
|
zoom = render(vec![]);
|
|
}
|
|
assert!(zoom.scale > 1.2);
|
|
let click = |pos, pressed| egui::Event::PointerButton {
|
|
pos,
|
|
button: egui::PointerButton::Primary,
|
|
pressed,
|
|
modifiers: egui::Modifiers::NONE,
|
|
};
|
|
render(vec![click(center, true)]);
|
|
let moved = center + Vec2::new(40., 10.);
|
|
let panned = render(vec![egui::Event::PointerMoved(moved)]);
|
|
assert!(panned.center[1] < zoom.center[1]);
|
|
assert_eq!(
|
|
panned.center[0], 0.5,
|
|
"page width still fits; horizontal panning should stop"
|
|
);
|
|
render(vec![click(moved, false)]);
|
|
for _ in 0..20 {
|
|
render(vec![]);
|
|
}
|
|
for _ in 0..2 {
|
|
render(vec![click(moved, true)]);
|
|
zoom = render(vec![click(moved, false)]);
|
|
}
|
|
assert_eq!(zoom, View::default());
|
|
}
|
|
|
|
#[test]
|
|
fn double_click_fits_width_near_target_then_resets_without_stretching() {
|
|
use deckstride::presenter_ui::{zoom_geometry, zoom_gestures_in};
|
|
for (dimensions, expected) in [([210, 297], 2.8285716), ([400, 100], 1.), ([10, 1000], 8.)] {
|
|
let ctx = Context::default();
|
|
let target = Rect::from_min_size(Pos2::new(40., 40.), Vec2::new(400., 200.));
|
|
let page = deckstride::presenter_ui::fitted_slide(target, dimensions);
|
|
let click_position = Pos2::new(page.center().x, page.top() + page.height() * 0.95);
|
|
let mut view = View::default();
|
|
let mut time = 0.;
|
|
let mut render = |events| {
|
|
time += 0.04;
|
|
let _ = ctx.run_ui(
|
|
RawInput {
|
|
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(500., 300.))),
|
|
events,
|
|
time: Some(time),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
view = zoom_gestures_in(ui, target, dimensions, view, false).0;
|
|
},
|
|
);
|
|
view
|
|
};
|
|
render(vec![egui::Event::PointerMoved(click_position)]);
|
|
for (index, expected_scale) in [expected, 1.].into_iter().enumerate() {
|
|
for _ in 0..20 {
|
|
render(vec![]);
|
|
}
|
|
let mut actual = View::default();
|
|
for _ in 0..2 {
|
|
for pressed in [true, false] {
|
|
actual = render(vec![egui::Event::PointerButton {
|
|
pos: click_position,
|
|
button: egui::PointerButton::Primary,
|
|
pressed,
|
|
modifiers: Default::default(),
|
|
}]);
|
|
}
|
|
}
|
|
assert!((actual.scale - expected_scale).abs() < 0.0001);
|
|
if index == 0 && expected_scale > 1. {
|
|
let (_, uv) = zoom_geometry(target, dimensions, actual, false);
|
|
let expected_y = 0.95_f32.min(1. - uv.height() * 0.5);
|
|
assert!((actual.center[1] - expected_y).abs() < 0.0001);
|
|
assert_eq!(actual.center[0], 0.5);
|
|
} else {
|
|
assert_eq!(actual.center, [0.5; 2]);
|
|
}
|
|
if actual.scale > 1. && actual.scale < 8. {
|
|
let (draw, uv) = zoom_geometry(target, dimensions, actual, false);
|
|
assert!((draw.width() - target.width()).abs() < 0.001);
|
|
assert!(
|
|
(uv.width() - 1.).abs() < 0.001,
|
|
"fit width must show the entire page width"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn fit_width_uses_output_shape_even_with_a_narrow_presenter_pane() {
|
|
use deckstride::presenter_ui::{fitted_slide, zoom_geometry};
|
|
let output = Rect::from_min_size(Pos2::ZERO, Vec2::new(1920., 1080.));
|
|
let pane = Rect::from_min_size(Pos2::ZERO, Vec2::new(300., 600.));
|
|
let preview = fitted_slide(pane, [1920, 1080]);
|
|
let scale = preview.width() / fitted_slide(preview, [210, 297]).width();
|
|
let view = View {
|
|
scale,
|
|
center: [0.5; 2],
|
|
};
|
|
let (preview_draw, preview_uv) = zoom_geometry(preview, [210, 297], view, false);
|
|
let (output_draw, output_uv) = zoom_geometry(output, [210, 297], view, false);
|
|
assert!((preview_draw.width() - preview.width()).abs() < 0.001);
|
|
assert!(
|
|
(output_draw.width() - output.width()).abs() < 0.001,
|
|
"output retained side borders"
|
|
);
|
|
assert!((preview_uv.min - output_uv.min).length() < 0.0001);
|
|
assert!((preview_uv.max - output_uv.max).length() < 0.0001);
|
|
}
|