From bb1f18a738538c0fb6c2753799712c641eddf4f2 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Fri, 20 Nov 2026 16:51:32 -0800 Subject: [PATCH] Revolve: check paint copies on the faces the fill rule draws Validation swept every profile under the nonzero rule while the surface is drawn under the object's own fill rule, so an even-odd profile's cut sides could be counted with a different number of faces than are drawn. The paint copies, graphics and shadow of an object, of each group member and of a fill's or stroke's Revolve are now checked under the rule the surface is drawn with. --- crates/effects/src/revolve.rs | 90 +++++++++++++++++++++++++++++------ 1 file changed, 76 insertions(+), 14 deletions(-) diff --git a/crates/effects/src/revolve.rs b/crates/effects/src/revolve.rs index 19522873f3..a6f0d6b2ae 100644 --- a/crates/effects/src/revolve.rs +++ b/crates/effects/src/revolve.rs @@ -158,14 +158,16 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) let mut copies = 0; // In wireframe mode the edges are drawn with no paint copies, graphics or shadow. let wire = wireframe_params(id, p); - shapes.iter().try_for_each(|s| check_surface(&s.path, b, options, surface_item(&s.items).filter(|_| !wire), &mut copies))?; + // Each member is swept with its own fill rule, as it is drawn. + let ruled = |s: &Profile| Revolve { fill_rule: s.rule, ..options }; + shapes.iter().try_for_each(|s| check_surface(&s.path, b, ruled(s), surface_item(&s.items).filter(|_| !wire), &mut copies))?; if wire { return Ok(()); } // Without graphics, or without the document they draw from, no member is measured for them. if let Some(doc) = doc.filter(|_| id == REVOLVE && !crate::solids::mapped_graphics(p).is_empty()) { match graphics_member(&shapes, b, options).and_then(|k| shapes.get(k)) { - Some(s) => check_graphics(Some(doc), id, &s.path, b, options, p, &mut 0)?, + Some(s) => check_graphics(Some(doc), id, &s.path, b, ruled(s), p, &mut 0)?, // With no member to carry them, the graphics' art must still fit its limits. None => { crate::solids::graphics::validate_symbols(doc, p)?; @@ -174,9 +176,9 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) } } let casting = shapes.iter().filter(|s| surface_item(&s.items).is_some_and(|i| crate::solids::shadow::casts(paint_of(i).1 * s.opacity))); - return check_shadow(p, casting.map(|s| &s.path), b, options); + return check_shadow(p, casting.map(|s| (&s.path, s.rule)), b, options); } - let (path, _) = object_profile(n, "Revolve")?; + let (path, rule) = object_profile(n, "Revolve")?; if !has_two_anchors(&path) { return Err("Revolve requires a shape with at least two anchors".into()); } @@ -184,12 +186,13 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) let b = path.bounds().ok_or("Revolve requires a shape with at least two anchors")?; let paints = solid_paints(n); let wire = wireframe_params(id, p); - check_surface(&path, b, options_of(id, p), surface_item(&paints).filter(|_| !wire), &mut 0)?; + let options = Revolve { fill_rule: rule, ..options_of(id, p) }; + check_surface(&path, b, options, surface_item(&paints).filter(|_| !wire), &mut 0)?; if wire { return Ok(()); } - check_graphics(doc, id, &path, b, options_of(id, p), p, &mut 0)?; - check_shadow(p, [&path], b, options_of(id, p)) + check_graphics(doc, id, &path, b, options, p, &mut 0)?; + check_shadow(p, [(&path, rule)], b, options) } /// An error when the graphics in Revolve (`id`) parameters `p`, with the symbols of `doc`, are past @@ -226,14 +229,14 @@ pub(crate) fn graphics_member(shapes: &[Profile], b: Rect, options: Revolve) -> .map(|(k, _)| k) } -/// With the shadow of Revolve parameters `p` on, an error when the surfaces of `paths` it is cast -/// from, about the axis of `b`, are past the limits together. -fn check_shadow<'a>(p: &Value, paths: impl IntoIterator, b: Rect, options: Revolve) -> Result<(), String> { +/// With the shadow of Revolve parameters `p` on, an error when the surfaces of `paths`, each filled +/// with its rule, it is cast from, about the axis of `b`, are past the limits together. +fn check_shadow<'a>(p: &Value, paths: impl IntoIterator, b: Rect, options: Revolve) -> Result<(), String> { if crate::solids::shadow::options(p).is_none() { return Ok(()); } let mut caster = vectorcraft_three_d::ShadowCaster::new(); - paths.into_iter().try_for_each(|path| caster.revolve(path, options.fill_rule, b, options).map(|_| ())) + paths.into_iter().try_for_each(|(path, rule)| caster.revolve(path, rule, b, Revolve { fill_rule: rule, ..options }).map(|_| ())) } /// [`validate_revolve`] for a Revolve with parameters `p` at index `index` of the effects of @@ -269,7 +272,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V validate_params_of(id, p)?; validate_map_symbols(doc, id, p)?; const EMPTY: &str = "Revolve requires a shape with at least two anchors"; - let (path, _) = object_profile(n, "Revolve")?; + let (path, rule) = object_profile(n, "Revolve")?; if !has_two_anchors(&path) { return Err(EMPTY.into()); } @@ -284,7 +287,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V Some(fx) if crate::paints(item) => (fx.id.as_str(), merged_params(&fx.id, &fx.params)), _ => continue, }; - let options = options_of(kind, ¶ms); + let options = Revolve { fill_rule: rule, ..options_of(kind, ¶ms) }; let path = geometry(&path, at.and_then(|at| effects.get(..at)).unwrap_or(effects), &ctx.item(item)); let b = path.bounds().ok_or(EMPTY)?; let wire = wireframe_params(kind, ¶ms); @@ -298,7 +301,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V if i == target { graphics?; } - check_shadow(¶ms, [&path], b, options)?; + check_shadow(¶ms, [(&path, rule)], b, options)?; } Ok(()) } @@ -1950,6 +1953,65 @@ mod tests { assert_eq!(revolve_art(&drawn), None, "past the budget the source draws"); } + #[test] + fn paint_copies_are_counted_on_the_faces_the_fill_rule_draws() { + use vectorcraft_doc::color::{Gradient, GradientKind, GradientPaint, GradientStop}; + use vectorcraft_geom::FillRule; + // Three nested squares drawn in the same direction, swept part way with Cap: under the + // even-odd rule each cut side is a ring and the inner square, and under the nonzero rule + // each cut side is one whole square. + let both = PathData::new( + [(100.0, 200.0), (120.0, 180.0), (140.0, 160.0)] + .iter() + .flat_map(|&(lo, hi)| { + let mut b = BezPath::new(); + b.move_to((lo, lo)); + b.line_to((hi, lo)); + b.line_to((hi, hi)); + b.line_to((lo, hi)); + b.close_path(); + PathData::from_bezpath(&b).subpaths + }) + .collect(), + ); + let p = json!({"angle": 180, "cap": true}); + let b = both.bounds().unwrap(); + let faces = |rule| vectorcraft_three_d::revolve(&both, b, Revolve { fill_rule: rule, ..revolve_options(&p) }).unwrap().len(); + let (drawn, other) = (faces(FillRule::EvenOdd), faces(FillRule::NonZero)); + assert_ne!(drawn, other, "the two rules draw different faces"); + // A gradient whose copies fit on the faces of one rule and not on those of the other. + let gradient = |n: usize| { + let stops = (0..n).map(|i| GradientStop::new(i as f32 / n as f32, Color::BLACK)).collect(); + Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops)))) + }; + let target = MAX_PAINT_COPIES / 4 * 2 / (drawn + other); + let paint = gradient(target / std::mem::size_of::()); + let bytes = paint_bytes(&paint); + let fits = |faces: usize| faces * 4 * bytes <= MAX_PAINT_COPIES; + assert_ne!(fits(drawn), fits(other), "{bytes} bytes per copy on {drawn} and {other} faces"); + // The surface is drawn on the even-odd faces, so validation counts the copies on them. + let expected = if fits(drawn) { + Ok(()) + } else { + Err("Revolve paint is too complex for this surface; reduce Segments or simplify the gradient".to_string()) + }; + let shape = |effects: Vec| { + let mut fill = AppearanceItem::Fill(FillLayer::new(paint.clone())); + fill.effects_mut().extend(effects); + crate::group::shape_node(NodeId(1), both.clone(), FillRule::EvenOdd, Appearance { items: vec![fill], ..Default::default() }) + }; + let revolve = || crate::new_effect(REVOLVE, &p).unwrap(); + let mut object = shape(vec![]); + assert_eq!(validate_revolve(&object, &p), expected, "an object"); + object.appearance.effects.push(revolve()); + assert_eq!(revolve_art(&object).is_some(), expected.is_ok(), "the object's surface draws when it is accepted"); + let group = group_with(p.clone(), vec![Arc::new(shape(vec![]))]); + assert_eq!(validate_revolve(&group, &p), expected, "a group's member"); + assert_eq!(revolve_art(&group).is_some(), expected.is_ok(), "the group's surface draws when it is accepted"); + let item = shape(vec![revolve()]); + assert_eq!(validate_item_of(None, &item, REVOLVE, &p, 0, 0), expected, "a fill's Revolve"); + } + /// Is `u` the underlay [`crate::lighting::underlay`] draws for `face`, a face [`surface`] draws? fn underlies(u: &Node, face: &Node) -> bool { match (&u.kind, &face.kind) {