diff --git a/crates/engine/src/tests/overprint.rs b/crates/engine/src/tests/overprint.rs index 3f18ddf644..e73825e86f 100644 --- a/crates/engine/src/tests/overprint.rs +++ b/crates/engine/src/tests/overprint.rs @@ -281,6 +281,10 @@ fn overprint_black_covers_type_gradients_spots_and_groups() { /// pixel (0 full ink, 255 none). fn plate(doc: &Document, plate: &str) -> Vec { let mut r = Renderer::new(); + plate_with_renderer(&mut r, doc, plate) +} + +fn plate_with_renderer(r: &mut Renderer, doc: &Document, plate: &str) -> Vec { r.threads = 0; let seps = vectorcraft_render::proof::ProofSetup { separations: Some(vec![plate.into()]), ..Default::default() }; let opts = RenderOptions { background: Some([255, 255, 255, 255]), proof: Some(seps), ..Default::default() }; @@ -304,8 +308,18 @@ fn classic_3d_black_overprint_shades_on_the_black_plate() { let (over_doc, flat_doc) = (&over.doc().unwrap().doc, &flat.doc().unwrap().doc); let inked = |p: &[u8]| p.iter().filter(|v| **v < 250).count(); assert!(inked(&plate(over_doc, "Cyan")) > 1000, "the solid is drawn"); + for name in ["Cyan", "Magenta", "Yellow"] { + let shaded = plate(over_doc, name); + let unshaded = plate(flat_doc, name); + let changed = shaded.iter().zip(&unshaded).filter(|(s, u)| s.abs_diff(**u) > 1).count(); + assert_eq!(changed, 0, "Black Overprint changes the {name} plate"); + } assert!(inked(&plate(over_doc, "Black")) > 100, "the shading is on the black plate"); assert_eq!(inked(&plate(flat_doc, "Black")), 0, "No Shading adds no black"); + let mut renderer = Renderer::new(); + let first_cyan = plate_with_renderer(&mut renderer, over_doc, "Cyan"); + assert!(inked(&plate_with_renderer(&mut renderer, over_doc, "Black")) > 100); + assert_eq!(plate_with_renderer(&mut renderer, over_doc, "Cyan"), first_cyan, "switching plates preserves the Cyan preview"); // On screen a shaded face is the cyan darkened, not gray: the black multiplies the cyan. let image = |d: &Document| { let mut r = Renderer::new(); diff --git a/crates/render/src/fx/renderer.rs b/crates/render/src/fx/renderer.rs index d0ad5d65e9..78a6ea236b 100644 --- a/crates/render/src/fx/renderer.rs +++ b/crates/render/src/fx/renderer.rs @@ -493,7 +493,27 @@ impl Renderer { { return self.draw_staged(ctx, f, stage, &bp, *rule); } - let art = self.fx_art(f.symbols, a, cache); + let separations = f.opts.proof.as_ref().filter(|proof| proof.separations.is_some()); + let key = Arc::as_ptr(a) as usize; + let previous = (cache && separations.is_some()).then(|| self.fx_arts.get(&key, self.stamp).map(|entry| entry.1.clone())).flatten(); + let mut art = self.fx_art(f.symbols, a, cache); + if let Some(proof) = separations + && previous.as_ref().is_none_or(|previous| !Arc::ptr_eq(previous, &art)) + { + let made = crate::proof::generated_black(f.doc, proof, &art); + if !Arc::ptr_eq(&made, &art) { + if let Some((_, bounds)) = self.three_d_bounds.remove(&(Arc::as_ptr(&art) as usize)) { + self.three_d_bounds.insert(Arc::as_ptr(&made) as usize, (Arc::downgrade(&made), bounds)); + } + if cache + && let Some((node, _, found)) = + self.fx_arts.get(&key, self.stamp).filter(|entry| Arc::ptr_eq(&entry.0, a) && Arc::ptr_eq(&entry.1, &art)).cloned() + { + self.fx_arts.insert(key, (node, made.clone(), found), crate::lru::node_bytes(&made), self.stamp); + } + art = made; + } + } // Art the cache did not keep is made again in the next frame. let kept = cache && self.fx_arts.get(&(Arc::as_ptr(a) as usize), self.stamp).is_some_and(|e| Arc::ptr_eq(&e.1, &art)); let outer = self.made_again; diff --git a/crates/render/src/proof.rs b/crates/render/src/proof.rs index 284ad8ce5d..e809afb4ee 100644 --- a/crates/render/src/proof.rs +++ b/crates/render/src/proof.rs @@ -28,11 +28,11 @@ use std::sync::{Arc, Mutex, OnceLock, RwLock, Weak}; use vectorcraft_color::cms::{self, Cms, CmykLut, PROCESS_PLATES, ProofLut, lab}; pub use vectorcraft_color::cms::{Intent, ProofSetup, ProofTarget}; -use vectorcraft_color::{Color, Swatch, SwatchGroup}; +use vectorcraft_color::{Color, Paint, Swatch, SwatchGroup}; pub use vectorcraft_doc::inks::{Inks, Link, Plate, inks, map_document_colors, map_node_colors, plates, spot_color}; use vectorcraft_doc::inks::{StopPlates, map_node_inks, stop_inks}; use vectorcraft_doc::overprint::darken_overprints; -use vectorcraft_doc::{Document, ImageBlob, Node, NodeId, Shared}; +use vectorcraft_doc::{AppearanceItem, Document, ImageBlob, Node, NodeId, Shared}; use vello_cpu::Pixmap; use vello_cpu::color::PremulRgba8; @@ -80,6 +80,46 @@ fn plate_color(doc: &Document, c: &Cms, proof: &ProofSetup, visible: &[String], Color::Rgb { r, g, b } } +/// Map grayscale inks created after document preparation to the visible plates. +pub(crate) fn generated_black(doc: &Document, proof: &ProofSetup, art: &Arc) -> Arc { + let Some(visible) = proof.separations.as_deref() else { return art.clone() }; + let c = cms::active(); + let mut made = Node::clone(art); + if !visible.iter().any(|plate| plate == "Black") { + hide_generated_black(&mut made); + } + let mut changed = false; + map_node_inks(&mut made, &mut |color, link, plates| { + // Document colors are already display RGB; newly generated black retains its Gray ink. + if matches!(color, Color::Gray { .. }) { + changed = true; + plate_color(doc, &c, proof, visible, color, link, plates) + } else { + *color + } + }); + if changed { Arc::new(made) } else { art.clone() } +} + +fn hide_generated_black(node: &mut Node) { + for item in &mut node.appearance.items { + match item { + AppearanceItem::Fill(layer) if layer.overprint && matches!(layer.paint, Paint::Solid { color: Color::Gray { .. }, swatch: None, .. }) => { + layer.visible = false; + } + AppearanceItem::Stroke(layer) + if layer.overprint && matches!(layer.paint, Paint::Solid { color: Color::Gray { .. }, swatch: None, .. }) => + { + layer.visible = false; + } + _ => {} + } + } + for child in node.children_mut().into_iter().flatten() { + hide_generated_black(Arc::make_mut(child)); + } +} + /// Separations Preview's tables for placed images: what the visible plates show of display pixels /// and of a CMYK image's own inks ([`plate_rgb`]), for one proof setup, color settings and set of /// profiles. Each table is made when an image first needs it.