Files
vectorcraft/crates/three-d/src/solid/tests_limits.rs
T
dotCooCoo a900653c9c 3D: Inflate limits the work of filling its grid
Inflate's grid clipped every ring of the outline in each cell the
outline crosses and tested every edge for each cell's center, so its
work grew with the outline's points times the cells: a comb of 4,000
teeth (16,002 points) took 1.1 to 1.3 s and one of 16,000 teeth 8.8 to
9.1 s. Inflate now counts that work (the edge index's entries, the edges
its queries look at and the ring points its cells clip) and refuses the
shape with "The 3D surface is too complex; simplify the shape" once it
passes 268,435,456, VectorCraft's own value (about 0.65 s). The index
takes at most 16,777,216 entries (64 MiB). Each row's inside test reads
the sorted crossings of its line, and a cell clips only the rings whose
bounds meet it, so a 65,536-point circle inflates in 0.66 s instead of
1.0 to 1.2 s.

The effects test of a stroke past the limits uses 40,000 corners, so its
outline passes the 65,536 points a solid takes.

Docs: docs/three-d.md, docs/mcp.md.
2026-11-10 10:43:24 -08:00

198 lines
10 KiB
Rust

use vectorcraft_geom::{Anchor, SubPath};
use super::*;
const SHAPE: &str = "The shape is too complex for a 3D effect";
const SURFACE: &str = "The 3D surface is too complex; simplify the shape";
/// A closed ring of `count` curved petals around a circle of `radius`: each curve leaves its anchor
/// outward, `lift` points out, and comes back to the next anchor, so a larger lift asks for more
/// pieces per curve.
fn petals(count: usize, radius: f64, lift: f64) -> PathData {
let chord = std::f64::consts::TAU * radius / count as f64;
let anchors = (0..count)
.map(|i| {
let (s, c) = (std::f64::consts::TAU * i as f64 / count as f64).sin_cos();
let p = Point::new(radius * 2.0 + radius * c, radius * 2.0 + radius * s);
let (out, along) = (Vec2::new(c, s) * lift, Vec2::new(-s, c) * (chord / 3.0));
Anchor::with_handles(p, p + out - along, p + out + along)
})
.collect();
PathData::new(vec![SubPath::new(anchors, true)])
}
/// A closed polygon of `count` straight edges around a circle.
fn polygon(count: usize, radius: f64) -> PathData {
let anchors = (0..count)
.map(|i| {
let (s, c) = (std::f64::consts::TAU * i as f64 / count as f64).sin_cos();
Anchor::corner(Point::new(radius * 2.0 + radius * c, radius * 2.0 + radius * s))
})
.collect();
PathData::new(vec![SubPath::new(anchors, true)])
}
/// Turned so that the walls and bevels show.
fn turned() -> View {
View { rotation_x: -18.0, rotation_y: -26.0, rotation_z: 8.0, ..View::default() }
}
fn size(path: &PathData) -> f64 {
let b = path.bounds().unwrap();
b.width().max(b.height())
}
/// How many points the outline samples to, each curve in at most `most` pieces.
fn points(path: &PathData, most: u32) -> usize {
rings::sample(path, size(path), usize::MAX, most).unwrap().iter().map(Vec::len).sum()
}
fn built(facets: &[Facet]) -> bool {
!facets.is_empty()
&& facets.len() <= MAX_SOLID_FACES
&& facets.iter().flat_map(|f| f.contours.iter().flatten()).all(|p| p.x.is_finite() && p.y.is_finite())
}
#[test]
fn two_thousand_curves_extrude_with_a_bevel_and_inflate() {
let path = petals(2000, 500.0, 4.0);
let b = path.bounds().unwrap();
// Every curve takes several pieces: far more points than 2,048, all of them kept.
let sampled = points(&path, rings::CURVE_PIECES);
assert!(sampled >= 3 * 2000, "{sampled}");
assert_eq!(rings::curve_pieces(&path, size(&path), 2, 2), Ok(rings::CURVE_PIECES));
let bevel = Extrude { bevel: Some(Bevel::default()), ..Extrude::default() };
let extruded = extrude(&path, FillRule::NonZero, b, bevel, turned()).unwrap();
assert!(built(&extruded) && extruded.len() > sampled, "{}", extruded.len());
let inflated = inflate(&path, FillRule::NonZero, b, Inflate::default(), turned()).unwrap();
assert!(built(&inflated), "{}", inflated.len());
}
#[test]
fn an_outline_at_the_point_limit_is_taken_and_one_past_it_is_refused_before_sampling() {
let at = polygon(MAX_SOLID_POINTS, 20_000.0);
assert_eq!(rings::curve_pieces(&at, size(&at), 1, 2), Ok(rings::CURVE_PIECES));
assert!(built(&extrude(&at, FillRule::NonZero, at.bounds().unwrap(), Extrude::default(), turned()).unwrap()));
let past = polygon(MAX_SOLID_POINTS + 1, 20_000.0);
assert_eq!(rings::curve_pieces(&past, size(&past), 1, 2), Err(SHAPE.to_string()));
assert_eq!(extrude(&past, FillRule::NonZero, past.bounds().unwrap(), Extrude::default(), turned()), Err(SHAPE.to_string()));
assert_eq!(inflate(&past, FillRule::NonZero, past.bounds().unwrap(), Inflate::default(), turned()), Err(SHAPE.to_string()));
}
#[test]
fn faces_at_the_limit_are_taken_and_one_past_it_is_refused_before_sampling() {
// 40,960 straight edges in four bands are exactly the face limit.
let path = polygon(MAX_SOLID_FACES / 4, 20_000.0);
assert_eq!(rings::curve_pieces(&path, size(&path), 4, 0), Ok(rings::CURVE_PIECES));
assert_eq!(rings::curve_pieces(&path, size(&path), 4, 1), Err(SURFACE.to_string()));
// A rounded bevel gives 20,000 edges nine bands each, past the limit.
let path = polygon(20_000, 20_000.0);
let rounded = Extrude { bevel: Some(Bevel { shape: BevelShape::Rounded, ..Bevel::default() }), ..Extrude::default() };
assert_eq!(extrude(&path, FillRule::NonZero, path.bounds().unwrap(), rounded, turned()), Err(SURFACE.to_string()));
}
#[test]
fn curves_over_the_budget_take_fewer_pieces_down_to_four() {
let path = petals(2000, 500.0, 20.0);
let s = size(&path);
assert_eq!(points(&path, rings::CURVE_PIECES), 6 * 2000, "six pieces a curve within the tolerance");
// 16 faces an edge: 12,000 points are too many, 10,000 at five pieces a curve fit.
assert_eq!(rings::curve_pieces(&path, s, 16, 0), Ok(5));
assert_eq!(points(&path, 5), 5 * 2000);
// At four pieces a curve, 21 faces an edge are still too many.
assert_eq!(rings::curve_pieces(&path, s, 21, 0), Err(SURFACE.to_string()));
// Twisted 96°, the walls are 16 slices: built with five pieces a curve.
let b = path.bounds().unwrap();
let twisted = extrude(&path, FillRule::NonZero, b, Extrude { twist: 96.0, hidden: true, ..Extrude::default() }, turned()).unwrap();
assert!(built(&twisted) && twisted.len() > MAX_FACES, "{}", twisted.len());
// Twisted 360°, 60 slices are too many even at four pieces a curve.
assert_eq!(extrude(&path, FillRule::NonZero, b, Extrude { twist: 360.0, ..Extrude::default() }, turned()), Err(SURFACE.to_string()));
}
#[test]
fn five_and_ten_thousand_curves_build_at_the_defaults() {
let five = petals(5000, 1250.0, 2.0);
assert!(built(&inflate(&five, FillRule::NonZero, five.bounds().unwrap(), Inflate::default(), turned()).unwrap()));
assert!(built(&extrude(&five, FillRule::NonZero, five.bounds().unwrap(), Extrude::default(), turned()).unwrap()));
let ten = petals(10_000, 2500.0, 4.0);
let b = ten.bounds().unwrap();
assert!(points(&ten, rings::CURVE_PIECES) > 10_000);
assert!(built(&extrude(&ten, FillRule::NonZero, b, Extrude::default(), turned()).unwrap()));
let deep = Extrude { twist: 360.0, bevel: Some(Bevel { shape: BevelShape::Rounded, repeat: 4, ..Bevel::default() }), ..Extrude::default() };
assert_eq!(extrude(&ten, FillRule::NonZero, b, deep, turned()), Err(SURFACE.to_string()));
}
#[test]
fn many_empty_contours_and_invalid_handles_are_refused_before_sampling() {
// Contours of one anchor and of none draw nothing, yet each is counted.
let lone = |i: usize| SubPath::new(if i.is_multiple_of(2) { vec![] } else { vec![Anchor::corner(Point::new(1.0, i as f64))] }, false);
let square = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(10.0, 10.0), Point::new(0.0, 10.0)], true);
let at = PathData::new((0..MAX_SOLID_POINTS - 1).map(lone).chain([square.clone()]).collect());
assert_eq!(rings::curve_pieces(&at, 10.0, 1, 2), Ok(rings::CURVE_PIECES));
let past = PathData::new((0..MAX_SOLID_POINTS).map(lone).chain([square.clone()]).collect());
assert_eq!(rings::curve_pieces(&past, 10.0, 1, 2), Err(SHAPE.to_string()));
let b = Rect::new(0.0, 0.0, 10.0, 10.0);
assert_eq!(extrude(&past, FillRule::NonZero, b, Extrude::default(), turned()), Err(SHAPE.to_string()));
let mut bad = square;
bad.anchors[1].h_out = Point::new(f64::NAN, 0.0);
let bad = PathData::new(vec![bad]);
assert_eq!(rings::curve_pieces(&bad, 10.0, 1, 2), Err("The shape contains invalid coordinates".to_string()));
assert_eq!(inflate(&bad, FillRule::NonZero, b, Inflate::default(), turned()), Err("The shape contains invalid coordinates".to_string()));
}
/// A comb of `teeth` teeth, 100 wide and 100 tall, on a strip along its foot: its outline
/// crosses every cell of the grid Inflate fills.
fn comb(teeth: usize) -> PathData {
let w = 100.0 / teeth as f64;
let mut points: Vec<Point> = (0..teeth)
.flat_map(|k| {
let x = k as f64 * w;
[Point::new(x, 0.0), Point::new(x, 100.0), Point::new(x + w / 2.0, 100.0), Point::new(x + w / 2.0, 0.0)]
})
.collect();
points.extend([Point::new(100.0, -1.0), Point::new(0.0, -1.0)]);
PathData::new(vec![SubPath::polyline(&points, true)])
}
/// Inflate `path` with the grid work its edge index may take set to `budget`.
fn inflated_within(path: &PathData, budget: usize) -> Result<Vec<Facet>, String> {
GRID_BUDGET.with(|b| b.set(budget));
let out = inflate(path, FillRule::NonZero, path.bounds().unwrap(), Inflate::default(), turned());
GRID_BUDGET.with(|b| b.set(MAX_GRID_WORK));
out
}
#[test]
fn inflate_at_its_grid_work_budget_builds_and_one_past_it_is_refused() {
let path = comb(200);
assert!(built(&inflated_within(&path, MAX_GRID_WORK).unwrap()));
let work = GRID_WORK.with(std::cell::Cell::get);
assert!(work > 0);
assert!(built(&inflated_within(&path, work).unwrap()));
assert_eq!(GRID_WORK.with(std::cell::Cell::get), work, "the same work at its budget");
assert_eq!(inflated_within(&path, work - 1), Err(SURFACE.to_string()));
}
#[test]
fn the_edge_index_at_its_entry_limit_is_built_and_one_past_it_is_refused() {
// A diagonal across the whole grid of 64 by 64 buckets is filed in every bucket, each way.
let diagonal = vec![Point::new(0.0, 0.0), Point::new(64.0, 64.0)];
assert_eq!(MAX_EDGE_ENTRIES, 2048 * 2 * 64 * 64);
let mut rings = vec![diagonal; 2048];
assert!(Edges::new(&rings).is_ok_and(|e| e.work() == MAX_EDGE_ENTRIES));
// A small triangle in one bucket: three entries more.
rings.push(vec![Point::new(0.0, 0.0), Point::new(0.5, 0.0), Point::new(0.0, 0.5)]);
assert_eq!(Edges::new(&rings).err(), Some(SURFACE.to_string()));
}
#[test]
fn a_comb_that_crosses_every_cell_is_refused_once_its_grid_work_is_spent() {
// Two thousand curves take a small share of the budget.
let curves = petals(2000, 500.0, 4.0);
assert!(built(&inflate(&curves, FillRule::NonZero, curves.bounds().unwrap(), Inflate::default(), turned()).unwrap()));
assert!(GRID_WORK.with(std::cell::Cell::get) < MAX_GRID_WORK / 16);
// 16,002 points, each clipped in every cell its ring meets.
let path = comb(4000);
assert_eq!(inflate(&path, FillRule::NonZero, path.bounds().unwrap(), Inflate::default(), turned()), Err(SURFACE.to_string()));
}