3D: a transparent gradient lines up its colors and transparency across the faces

Follows #7338. Under colored lights, and under the classic effects'
shading, a gradient with transparent stops is drawn opaque on each face
under one opacity mask of its transparency. A gradient without a
placement of its own fitted its colors to each face's bounds, while the
mask fitted the whole solid, so the color and transparency ramps did not
line up and the colors started over on each face. Such a gradient is now
placed once on all of the solid's faces, grown by 1 pt, before it is
split into colors and mask. Opaque gradients and placed gradients are
drawn as before.
This commit is contained in:
dotCooCoo
2026-11-15 10:18:36 -08:00
parent 5bd8acfce9
commit 402b62b20d
5 changed files with 82 additions and 5 deletions
+16
View File
@@ -321,6 +321,22 @@ pub(crate) fn opaque_paint(paint: &Paint) -> (Paint, Option<Paint>) {
(base, transparent.then_some(mask))
}
/// [`opaque_paint`] for a surface of several faces under one opacity mask. A transparent gradient
/// without a placement (or a freeform gradient without points) is first pinned to `bounds`, the
/// faces' bounds together grown by 1 pt, so every face's color and the mask share one placement.
/// An opaque gradient is returned as [`opaque_paint`] returns it.
pub(crate) fn opaque_surface_paint(paint: &Paint, bounds: impl FnOnce() -> vectorcraft_geom::Rect) -> (Paint, Option<Paint>) {
let (base, mask) = opaque_paint(paint);
if mask.is_none() || !matches!(paint, Paint::Gradient(_)) {
return (base, mask);
}
let mut pinned = paint.clone();
if let Paint::Gradient(g) = &mut pinned {
g.pin(bounds().inflate(1.0, 1.0));
}
opaque_paint(&pinned)
}
fn composed_art(id: vectorcraft_doc::NodeId, path: &vectorcraft_geom::PathData, paint: &Paint, light: Ramp, seam: f64) -> vectorcraft_doc::Node {
use std::sync::Arc;
use vectorcraft_doc::color::BlendMode;
+9 -2
View File
@@ -625,7 +625,9 @@ pub fn validate_three_d_params(id: &str, p: &Value) -> Result<(), String> {
/// blend mode (so overlapping facets don't add up their transparency). Under colored lights a solid
/// color with smooth facets is one composite of all its facets ([`composites_facets`]) unless
/// `faces`: then each facet is a face of its own, as in a gradient, so the faces can go in one order
/// with the faces of other solids.
/// with the faces of other solids. Under colored lights a gradient with transparent stops is drawn
/// opaque under one mask of its transparency, placed once on all the facets when it has no
/// placement of its own ([`crate::lighting::opaque_surface_paint`]).
fn surface(n: &Node, facets: Vec<Facet>, paint: &Paint, opacity: f32, blend: BlendMode, colored: bool, faces: bool) -> Node {
if !faces && composites_facets(&facets, paint, colored) {
let mut group = crate::lighting::solid_surface(n.id, &facets, paint);
@@ -634,7 +636,7 @@ fn surface(n: &Node, facets: Vec<Facet>, paint: &Paint, opacity: f32, blend: Ble
return group;
}
// Preserve existing white-light paints and alpha composition exactly.
let (opaque, mask) = if colored { crate::lighting::opaque_paint(paint) } else { (paint.clone(), None) };
let (opaque, mask) = if colored { crate::lighting::opaque_surface_paint(paint, || facets_bounds(&facets)) } else { (paint.clone(), None) };
let paint = &opaque;
let children = facets
.into_iter()
@@ -671,6 +673,11 @@ fn surface(n: &Node, facets: Vec<Facet>, paint: &Paint, opacity: f32, blend: Ble
group
}
/// The bounds of every facet of `facets` together (`Rect::ZERO` when none has any).
pub(crate) fn facets_bounds(facets: &[Facet]) -> Rect {
facets.iter().filter_map(|f| f.path().bounds()).reduce(|a, c| a.union(c)).unwrap_or(Rect::ZERO)
}
/// The width of the stroke of a facet's own paint that closes the seams between `face` and its
/// neighbors. No wider than the facet is thick: seen at a grazing angle a facet can be thinner than
/// the stroke, and its stroke would then paint over its neighbors.
+3 -2
View File
@@ -231,14 +231,15 @@ pub(crate) fn stroke_width(face: &Facet, p: &Value) -> f64 {
/// for each facet: the edges of the faces on Wireframe, else each face filled in its paint shaded by
/// its tone and highlight (with Preserve Spot Colors, a color linked to a swatch as [`linked_face`]
/// draws it). A gradient with transparent stops is shaded opaque and then masked by
/// its own transparency, so the shading follows the gradient's coverage.
/// its own transparency, so the shading follows the gradient's coverage; without a placement of its
/// own, it is placed once on all the faces ([`crate::lighting::opaque_surface_paint`]).
pub(crate) fn surface(n: &Node, facets: Vec<Facet>, source: &Paint, opacity: f32, blend: BlendMode, p: &Value) -> Node {
let shading = classic_shading(p);
let lights = lights(p);
let shade = shading_color(p);
let preserve = preserves_spot_colors(p);
let wire = shading.surface == ClassicSurface::Wireframe;
let (paint, mask) = if wire { (source.clone(), None) } else { crate::lighting::opaque_paint(source) };
let (paint, mask) = if wire { (source.clone(), None) } else { crate::lighting::opaque_surface_paint(source, || super::facets_bounds(&facets)) };
let paint = &paint;
let children = facets
.into_iter()
+51
View File
@@ -1960,6 +1960,57 @@ fn classic_shading_keeps_a_gradients_transparency() {
}
}
/// A gradient without a placement and with a transparent stop, under colored lights or classic
/// shading, is placed once for the whole surface: every face's color and the surface's opacity mask
/// share one placement, so the color and transparency ramps line up across the faces. A gradient
/// placed in the document keeps its placement.
#[test]
fn a_transparent_unplaced_gradient_has_one_placement_for_color_and_mask() {
use vectorcraft_doc::color::{Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop};
// The source's stops carry an unusual midpoint, so its color and mask copies can be told from
// the light ramps.
const MARK: f32 = 0.37;
let mut first = GradientStop::new(0.0, RED);
first.midpoint = MARK;
let mut end = GradientStop::new(1.0, Color::BLACK);
end.opacity = 0.25;
let unplaced = GradientPaint::new(Gradient::new(GradientKind::Linear, vec![first, end]));
let placed = GradientGeom { start: Point::new(90.0, 100.0), end: Point::new(230.0, 140.0), aspect: 1.0, focal: None };
// The placement of each copy of the source gradient: its own, else its fit on the path it fills.
fn placements(n: &Node, out: &mut Vec<GradientGeom>) {
n.walk(&mut |c| {
if let Some(mask) = &c.extras().mask {
placements(&mask.art, out);
}
let bounds = c.path_data().and_then(|p| p.bounds()).unwrap_or(Rect::ZERO);
for item in &c.appearance.items {
if let Paint::Gradient(g) = paint_ref(item)
&& g.gradient.stops.first().is_some_and(|s| s.midpoint == MARK)
{
out.push(g.resolve(bounds));
}
}
});
}
let lit = json!({"lights": [{"color": "#ff8080"}]});
for (id, params) in [(EXTRUDE, lit.clone()), (INFLATE, lit.clone()), (ROTATE, lit), (CLASSIC_EXTRUDE, json!({}))] {
for geom in [None, Some(placed)] {
let mut n = square_node();
n.appearance.items = vec![AppearanceItem::Fill(FillLayer::new(Paint::Gradient(Box::new(GradientPaint { geom, ..unplaced.clone() }))))];
n.appearance.effects.push(fx(id, params.clone()));
let art = solid_art(&n).unwrap_or_else(|| panic!("{id}"));
let mut masks = 0;
art.walk(&mut |c| masks += usize::from(c.extras().mask.is_some()));
assert!(masks > 0, "{id}: the surface carries the gradient's transparency as a mask");
let mut found = vec![];
placements(&art, &mut found);
assert!(found.len() > 2, "{id}: the faces' colors and the mask");
let expected = geom.unwrap_or(found[0]);
assert!(found.iter().all(|g| *g == expected), "{id} {geom:?}: {found:?}");
}
}
}
/// A group member in a gradient with transparent stops keeps the shared back-to-front order of
/// every member's faces: its faces go in runs that carry its opacity mask, and the other member's
/// faces are drawn between them where they are in front of some and behind others. Here a square
+3 -1
View File
@@ -180,7 +180,9 @@ The rest is our reading:
curved surfaces follow this only as closely as their flat facets do. A solid painted with a gradient that has
transparent stops under a light that is not white is drawn with an opacity mask: its faces keep their places in
this order, in runs that each carry the mask, and a graphic drawn after one of its faces carries the mask too
([Graphics](#graphics)). A member of a 3D group with its own opacity
([Graphics](#graphics)). Such a gradient, and a gradient with transparent stops under the classic effects'
shading, is placed once on the whole solid when it has no placement of its own, so its colors and its
transparency line up across the faces. A member of a 3D group with its own opacity
mask or blending mode draws its fill's and strokes' faces in this order inside that mask or blending mode when
they are opaque with Normal blending. Otherwise each solid is drawn on its own with its opacity and blending, the
lower item's first. With a light that is not white, a puffed, shaded Inflate surface in a solid color takes its