use super::*;
fn rect(x: f32) -> Path2D {
let mut path = Path2D::new();
path.rect(x, 0., 10., 10.);
path
}
fn canvas() -> CanvasHandle {
let canvas = CanvasHandle::new();
canvas.inner.lock().attached = true;
canvas
}
fn prepare(canvas: &CanvasHandle, cache: &mut MeshCache) -> Prepared {
let batch = canvas.take_batch().unwrap();
let prepared = Prepared::new(&batch.commands, cache).unwrap();
batch.submit();
prepared
}
fn area(vertices: &[Vertex]) -> f32 {
vertices
.chunks_exact(3)
.map(|v| {
let [a, b, c] = [v[0].position, v[1].position, v[2].position];
((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])).abs() * 0.5
})
.sum()
}
#[test]
fn camera_color_rule_and_edits_use_the_right_mesh() {
let canvas = canvas();
let d = canvas.context_2d();
let mut cache = MeshCache::default();
let mut path = rect(0.);
path.rect(2., 2., 6., 6.);
for i in 0..20 {
d.clear();
d.set_transform(Transform2D::translate(i as f32, 3.).then(&Transform2D::scale(2., -3.)));
d.set_fill_style(if i % 2 == 0 { "#ff000080" } else { "#00ff00" });
d.fill_path(&path, FillRule::EvenOdd);
let p = prepare(&canvas, &mut cache);
assert!((area(&p.vertices) - 64. * 6.).abs() < 0.01);
assert_eq!(p.steps[0].draw().unwrap().bounds, [i as f32, -27., i as f32 + 20., 3.]);
assert_eq!(p.vertices[0].color[1], if i % 2 == 0 { 0. } else { 1. });
}
assert_eq!(
cache.misses, 1,
"polygon pans/zooms/reflections and color changes reuse geometry"
);
d.fill_path(&path, FillRule::NonZero);
assert!((area(&prepare(&canvas, &mut cache).vertices) - 100. * 6.).abs() < 0.01);
assert_eq!(cache.misses, 2, "fill rule affects the triangles");
let old = path.clone();
d.fill_path(&path, FillRule::NonZero);
path.rect(20., 0., 10., 10.);
assert!(
(area(&prepare(&canvas, &mut cache).vertices) - 600.).abs() < 0.01,
"queued path is immutable"
);
d.fill_path(&path, FillRule::NonZero);
assert!((area(&prepare(&canvas, &mut cache).vertices) - 1200.).abs() < 0.01);
d.fill_path(&old, FillRule::NonZero);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, 3, "editing a clone does not invalidate its sibling");
let mut rebuilt = rect(0.);
rebuilt.rect(2., 2., 6., 6.);
d.fill_path(&rebuilt, FillRule::EvenOdd);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, 3, "identical rebuilt geometry hits by content");
}
#[test]
fn curves_follow_scale_buckets_including_dpi_skew_and_rotation() {
let mut path = Path2D::new();
path
.arc(0., 0., 20., 0., std::f32::consts::TAU, ArcDirection::Clockwise)
.unwrap();
let path = path.geometry().unwrap();
let mut cache = MeshCache::default();
for scale in [1.1, 1.5, 1.9, 1.2] {
let m = Transform2D::translate(73., -8.).then(&Transform2D::scale_uniform(scale));
cache
.append(&path, m, FillRule::NonZero, [1.; 4], None, &mut Vec::new())
.unwrap();
assert_eq!(tolerance(&path, m), 0.05);
}
assert_eq!(cache.misses, 1);
let m = Transform2D::scale_uniform(2.).then(&Transform2D::scale_uniform(1.1));
cache
.append(&path, m, FillRule::NonZero, [1.; 4], None, &mut Vec::new())
.unwrap();
assert_eq!(cache.misses, 2, "DPI participates in flattening scale");
assert_eq!(tolerance(&path, m), 0.025);
for m in [
Transform2D::rotate(0.7).then(&Transform2D::scale(-3., 0.5)),
Transform2D::skew(1.2, 0.3),
] {
let tolerance = tolerance(&path, m);
for i in 0..360 {
let (y, x) = (i as f32 * std::f32::consts::PI / 180.).sin_cos();
let (x, y) = m.transform_point(x, y);
assert!(tolerance * x.hypot(y) <= 0.10001);
}
}
}
#[test]
fn clip_transform_is_frozen_and_stroke_style_changes_invalidate() {
let canvas = canvas();
canvas.inner.lock().metrics.scale_factor = 2.;
let d = canvas.context_2d();
let mut cache = MeshCache::default();
let path = rect(0.);
d.set_transform(Transform2D::translate(5., 7.));
d.clip_path(&path, FillRule::NonZero);
d.set_transform(Transform2D::scale_uniform(3.));
d.set_line_width(2.);
d.stroke_path(&path);
let p = prepare(&canvas, &mut cache);
let clip = p.steps[0].draw().unwrap().clips[0].clone();
let clip_vertices = &p.vertices[clip.start as usize..clip.end as usize];
assert!((area(clip_vertices) - 400.).abs() < 0.01);
assert!(
clip_vertices
.iter()
.all(|v| v.position[0] >= 10. && v.position[0] <= 30. && v.position[1] >= 14. && v.position[1] <= 34.)
);
assert_eq!(p.steps[0].draw().unwrap().bounds, [-6., -6., 66., 66.]);
let misses = cache.misses;
d.translate(4., 0.);
d.stroke_path(&path);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, misses, "unchanged outline and clip reuse triangles");
d.set_line_width(4.);
d.stroke_path(&path);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, misses + 1);
d.set_line_dash(&[2., 2.]);
d.stroke_path(&path);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, misses + 2);
d.set_line_dash_offset(1.);
d.stroke_path(&path);
prepare(&canvas, &mut cache);
assert_eq!(cache.misses, misses + 3);
}
#[test]
fn cache_eviction_bounds_payload_metadata_and_oversized_entries() {
let key = |i| Key {
path: rect(i as f32).geometry().unwrap(),
rule: FillRule::NonZero,
tolerance: 0.1_f32.to_bits(),
};
let mut cache = MeshCache::default();
let positions: Arc<[[f32; 2]]> = vec![[0.; 2]; MAX_CACHE_BYTES / 8 / 4].into();
for i in 0..10 {
cache.insert(key(i), positions.clone());
assert!(cache.bytes <= MAX_CACHE_BYTES);
assert_eq!(cache.keys.len(), cache.entries.len());
}
assert_eq!(cache.entries.len(), 3);
assert!(cache.evictions > 0);
let oversized: Arc<[[f32; 2]]> = vec![[0.; 2]; MAX_CACHE_BYTES / 8].into();
cache.insert(key(50), oversized);
assert_eq!(cache.entries.len(), 3, "oversized entries bypass retention");
let mut cache = MeshCache::default();
for i in 0..MAX_CACHE_ENTRIES + 10 {
cache.insert(key(i), Arc::from([]));
}
assert_eq!(cache.entries.len(), MAX_CACHE_ENTRIES);
assert_eq!(cache.keys.len(), MAX_CACHE_ENTRIES);
assert!(cache.bytes <= MAX_CACHE_BYTES);
assert!(cache.evictions > 0);
}
#[test]
fn cached_meshes_preserve_vertex_limit_and_reject_nonfinite_transforms() {
let mut cache = MeshCache::default();
let path = rect(0.).geometry().unwrap();
let mut output = Vec::new();
cache
.append(
&path,
Transform2D::IDENTITY,
FillRule::NonZero,
[1.; 4],
None,
&mut output,
)
.unwrap();
output.resize(MAX_VERTICES - 3, output[0]);
assert_eq!(
cache.append(
&path,
Transform2D::IDENTITY,
FillRule::NonZero,
[1.; 4],
None,
&mut output
),
Err(CanvasError::StateLimit)
);
assert_eq!(cache.misses, 1, "the limit applies on cache hits");
output.clear();
cache
.append(
&path,
Transform2D::scale_uniform(f32::MAX),
FillRule::NonZero,
[1.; 4],
None,
&mut output,
)
.unwrap();
assert!(output.is_empty());
}
#[test]
fn repeated_over_capacity_scans_keep_useful_meshes() {
let paths: Vec<_> = (0..MAX_CACHE_ENTRIES + MAX_CACHE_ENTRIES / 5)
.map(|i| rect(i as f32).geometry().unwrap())
.collect();
let mut cache = MeshCache::default();
let mut vertices = Vec::new();
for frame in 0..3 {
let before = cache.stats();
for path in &paths {
vertices.clear();
cache
.append(
path,
Transform2D::translate(frame as f32, 0.),
FillRule::NonZero,
[1.; 4],
None,
&mut vertices,
)
.unwrap();
assert!((area(&vertices) - 100.).abs() < 0.01);
}
let after = cache.stats();
assert!(after.entries <= MAX_CACHE_ENTRIES && after.bytes <= MAX_CACHE_BYTES);
if frame > 0 {
let hits = after.hits - before.hits;
assert!(
hits > paths.len() as u64 / 2,
"warm scan hit only {hits}/{} paths",
paths.len()
);
assert!(after.misses > before.misses, "the working set exceeds capacity");
}
}
}
#[test]
fn cache_counters_are_attributed_to_the_canvas_being_prepared() {
let first = canvas();
let second = canvas();
let path = rect(0.);
let mut cache = MeshCache::default();
for owner in [&first, &second, &first] {
owner.context_2d().fill_path(&path, FillRule::NonZero);
let before = cache.stats();
prepare(owner, &mut cache);
owner.record_mesh_cache(before, cache.stats());
}
let first = first.status().gpu;
let second = second.status().gpu;
assert_eq!((first.mesh_cache_hits, first.mesh_cache_misses), (1, 1));
assert_eq!((second.mesh_cache_hits, second.mesh_cache_misses), (1, 0));
assert_eq!(first.mesh_cache_entries, 1);
assert!(first.mesh_cache_bytes > 0);
}