mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-30 12:47:13 -06:00
refactor(render): move lib.rs items to {blobs,bounds,clock,frame,geometry,node_checks,options,paint,renderer,renderer/images,renderer/nodes,renderer/paint,renderer/text,text_geom,threads}.rs
This commit is contained in:
aiongg
@@ -0,0 +1,205 @@
|
||||
use super::*;
|
||||
use crate::images;
|
||||
|
||||
impl Renderer {
|
||||
pub(crate) fn draw_image(&mut self, ctx: &mut RenderContext, f: &Frame, im: &vectorcraft_doc::ImageObject) {
|
||||
self.draw_image_in(ctx, f, im, None);
|
||||
}
|
||||
|
||||
/// Draw an image, or with `area` (a region in the document inside the image's frame, see
|
||||
/// [`plain_image`]) the image painted into that region.
|
||||
pub(super) fn draw_image_in(
|
||||
&mut self,
|
||||
ctx: &mut RenderContext,
|
||||
f: &Frame,
|
||||
im: &vectorcraft_doc::ImageObject,
|
||||
area: Option<&(BezPath, FillRule)>,
|
||||
) {
|
||||
let rect = Rect::new(0.0, 0.0, im.width as f64, im.height as f64);
|
||||
// Outline mode draws the image's frame, and with Document Setup → Show Images in Outline
|
||||
// Mode its pixels in greyscale under the frame.
|
||||
let outline = f.opts.outline;
|
||||
// With mips the full pixels are only looked at (not marked used) until they're drawn, and
|
||||
// a mip the store holds is drawn without them: they may have been dropped (#2820).
|
||||
let mips = f.opts.image_mips;
|
||||
let unit = f.view * im.xf * Affine::scale_non_uniform(im.width as f64, im.height as f64);
|
||||
let shown = if outline && !f.doc.setup.outline_images {
|
||||
None
|
||||
} else if let Some(pm) = mips.then(|| self.kept_mip(f, &im.key, im.pixels.as_deref(), outline, unit)).flatten() {
|
||||
Some(pm)
|
||||
} else {
|
||||
self.image_pixmap(f.doc, &im.key, im.pixels.as_deref(), outline, !mips).map(|(key, pm)| {
|
||||
let (key, pm) = if outline { (key, pm) } else { ink::ink_image(&key, &pm, f.ink, f.doc.image_blob(im), !mips) };
|
||||
if mips { image_mip(&key, pm, unit) } else { pm }
|
||||
})
|
||||
};
|
||||
if let Some(pm) = shown {
|
||||
let sx = im.width as f64 / pm.width().max(1) as f64;
|
||||
let sy = im.height as f64 / pm.height().max(1) as f64;
|
||||
let quality = if f.opts.smooth_images { peniko::ImageQuality::Medium } else { peniko::ImageQuality::Low };
|
||||
let sampler = peniko::ImageSampler { quality, ..Default::default() };
|
||||
ctx.set_paint(vello_cpu::Image { image: vello_cpu::ImageSource::Pixmap(pm), sampler });
|
||||
match area {
|
||||
Some((bp, rule)) => {
|
||||
ctx.set_transform(f.view);
|
||||
ctx.set_paint_transform(im.xf * Affine::scale_non_uniform(sx, sy));
|
||||
ctx.set_fill_rule(fill_rule(*rule));
|
||||
ctx.fill_path(bp);
|
||||
}
|
||||
None => {
|
||||
ctx.set_transform(f.view * im.xf);
|
||||
ctx.set_paint_transform(Affine::scale_non_uniform(sx, sy));
|
||||
ctx.fill_rect(&rect);
|
||||
}
|
||||
}
|
||||
ctx.reset_paint_transform();
|
||||
// A dimmed layer's images: white over them, so they show at that opacity on paper.
|
||||
if let Some(dim) = self.dim_images.filter(|d| *d < 1.0 && !outline) {
|
||||
ctx.set_paint(f.ink.fixed([255, 255, 255, ((1.0 - dim) * 255.0).round() as u8]));
|
||||
match area {
|
||||
Some((bp, rule)) => {
|
||||
ctx.set_transform(f.view);
|
||||
ctx.set_fill_rule(fill_rule(*rule));
|
||||
ctx.fill_path(bp);
|
||||
}
|
||||
None => {
|
||||
ctx.set_transform(f.view * im.xf);
|
||||
ctx.fill_rect(&rect);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if f.opts.mark_undecoded_images && (!outline || f.doc.setup.outline_images) {
|
||||
self.draw_undecoded_mark(ctx, f, im, area);
|
||||
}
|
||||
if outline {
|
||||
let mut p = rect.to_path(0.1);
|
||||
p.apply_affine(im.xf);
|
||||
self.hairline(ctx, f, &p, [0, 0, 0, 255]);
|
||||
}
|
||||
}
|
||||
|
||||
/// Draw the mark of image `im` whose pixels can't be had ([`RenderOptions::mark_undecoded_images`]):
|
||||
/// a light gray box over its frame, crossed from corner to corner with a gray hairline, and
|
||||
/// with `area` (see [`Self::draw_image_in`]) only inside that region.
|
||||
fn draw_undecoded_mark(&mut self, ctx: &mut RenderContext, f: &Frame, im: &vectorcraft_doc::ImageObject, area: Option<&(BezPath, FillRule)>) {
|
||||
let (w, h) = (im.width as f64, im.height as f64);
|
||||
if let Some((bp, rule)) = area {
|
||||
ctx.set_transform(f.view);
|
||||
ctx.set_fill_rule(fill_rule(*rule));
|
||||
ctx.push_clip_layer(bp);
|
||||
}
|
||||
let rect = Rect::new(0.0, 0.0, w, h);
|
||||
ctx.set_transform(f.view * im.xf);
|
||||
ctx.set_paint(f.ink.fixed([128, 128, 128, 40]));
|
||||
ctx.fill_rect(&rect);
|
||||
let mut cross = rect.to_path(0.1);
|
||||
cross.move_to((0.0, 0.0));
|
||||
cross.line_to((w, h));
|
||||
cross.move_to((w, 0.0));
|
||||
cross.line_to((0.0, h));
|
||||
cross.apply_affine(im.xf);
|
||||
self.hairline(ctx, f, &cross, [128, 128, 128, 255]);
|
||||
if area.is_some() {
|
||||
ctx.pop_layer();
|
||||
}
|
||||
}
|
||||
|
||||
/// Name image `key` recoloured by `map` (its hash `hash`) as `derived` (the key the adjusted
|
||||
/// art's image takes): drawing `derived` draws the recoloured pixels, made when first drawn and
|
||||
/// kept with the decoded images. Names past a limit drop the art made with them too, so it is
|
||||
/// made again.
|
||||
pub(crate) fn adjusted_image(&mut self, key: &str, derived: String, hash: u64, map: &vectorcraft_effects::ColorMap) {
|
||||
if self.adjusts.contains_key(&derived) {
|
||||
return;
|
||||
}
|
||||
if self.adjusts.len() >= 1024 {
|
||||
self.adjusts.clear();
|
||||
self.fx_arts.clear();
|
||||
}
|
||||
self.adjusts.insert(derived, (key.to_string(), hash, map.clone()));
|
||||
}
|
||||
|
||||
/// The pixels of image `key` (`own`, the pixels an image holds itself, a blob of `doc`, or a
|
||||
/// recoloured one named by [`Self::adjusted_image`]), or a greyscale copy of them, with their
|
||||
/// key in the shared store. `touch` marks them used there.
|
||||
pub(crate) fn image_pixmap(
|
||||
&mut self,
|
||||
doc: &Document,
|
||||
key: &str,
|
||||
own: Option<&vectorcraft_doc::ImageBlob>,
|
||||
grey: bool,
|
||||
touch: bool,
|
||||
) -> Option<(images::ImageKey, Arc<Pixmap>)> {
|
||||
let (key, colour) = match own.or_else(|| doc.images.get(key)) {
|
||||
Some(blob) => blob_pixmap(blob, touch)?,
|
||||
None => {
|
||||
let (src, hash, map) = self.adjusts.get(key)?.clone();
|
||||
let (src_key, src) = self.image_pixmap(doc, &src, None, false, touch)?;
|
||||
let key = images::ImageKey { adjust: Some(hash), ..src_key };
|
||||
match lookup(&key, touch) {
|
||||
Some(pm) => (key, pm),
|
||||
None => {
|
||||
let mut pm = (*src).clone();
|
||||
let mut memo: HashMap<[u8; 4], [u8; 3]> = HashMap::new();
|
||||
for px in pm.data_mut().iter_mut().filter(|p| p.a > 0) {
|
||||
let a = px.a as u32;
|
||||
let [r, g, b] = *memo.entry([px.r, px.g, px.b, px.a]).or_insert_with(|| {
|
||||
// Premultiplied to straight, adjusted, then premultiplied again.
|
||||
let straight = [px.r, px.g, px.b].map(|v| ((v as u32 * 255 + a / 2) / a).min(255) as u8);
|
||||
map.apply_rgb8(straight).map(|v| ((v as u32 * a + 127) / 255) as u8)
|
||||
});
|
||||
(px.r, px.g, px.b) = (r, g, b);
|
||||
}
|
||||
let pm = images::store().insert(key.clone(), Arc::new(pm));
|
||||
(key, pm)
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
if !grey {
|
||||
return Some((key, colour));
|
||||
}
|
||||
let key = images::ImageKey { grey: true, ..key };
|
||||
if let Some(p) = lookup(&key, touch) {
|
||||
return Some((key, p));
|
||||
}
|
||||
let mut pm = (*colour).clone();
|
||||
for px in pm.data_mut() {
|
||||
// The luma of premultiplied components is the premultiplied luma.
|
||||
let l = (0.2126 * px.r as f32 + 0.7152 * px.g as f32 + 0.0722 * px.b as f32 + 0.5) as u8;
|
||||
(px.r, px.g, px.b) = (l, l, l);
|
||||
}
|
||||
let pm = images::store().insert(key.clone(), Arc::new(pm));
|
||||
Some((key, pm))
|
||||
}
|
||||
|
||||
/// The key [`Self::image_pixmap`] gives the pixels of image `key` (or `own`) and their size, without
|
||||
/// making or looking at them: `None` until the image has been decoded.
|
||||
fn image_key(&self, doc: &Document, key: &str, own: Option<&vectorcraft_doc::ImageBlob>, grey: bool) -> Option<(images::ImageKey, (u16, u16))> {
|
||||
let (key, size) = match own.or_else(|| doc.images.get(key)) {
|
||||
Some(blob) => {
|
||||
let (key, _, size) = blob_key(blob);
|
||||
(key, size?)
|
||||
}
|
||||
None => {
|
||||
let (src, hash, _) = self.adjusts.get(key)?;
|
||||
let (src_key, size) = self.image_key(doc, src, None, false)?;
|
||||
(images::ImageKey { adjust: Some(*hash), ..src_key }, size)
|
||||
}
|
||||
};
|
||||
Some((if grey { images::ImageKey { grey: true, ..key } } else { key }, size))
|
||||
}
|
||||
|
||||
/// The mip [`image_mip`] draws image `key` (or `own`) with through `m`, in greyscale with
|
||||
/// `grey` (the outline view's), when the store holds it, marked used there; `None` when it
|
||||
/// draws the full pixels or the mip is yet to be made.
|
||||
fn kept_mip(&self, f: &Frame, key: &str, own: Option<&vectorcraft_doc::ImageBlob>, grey: bool, m: Affine) -> Option<Arc<Pixmap>> {
|
||||
let (key, (w, h)) = self.image_key(f.doc, key, own, grey)?;
|
||||
let key = if grey { key } else { ink::ink_key(&key, f.ink) };
|
||||
let level = mip_level(m, w, h);
|
||||
if level == 0 {
|
||||
return None;
|
||||
}
|
||||
images::store().get(&images::ImageKey { mip: level, ..key })
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,589 @@
|
||||
use super::*;
|
||||
|
||||
impl Renderer {
|
||||
/// Cached cull bounds of a node (containers union their cached children), symbol instances
|
||||
/// measured by their art box from `symbols`.
|
||||
pub(crate) fn bounds_of(&mut self, symbols: &SymbolBoxes, a: &Arc<Node>) -> Option<Rect> {
|
||||
let key = Arc::as_ptr(a) as usize;
|
||||
if let Some(e) = self.geom.get_mut(&key)
|
||||
&& Arc::ptr_eq(&e.node, a)
|
||||
{
|
||||
e.stamp = self.stamp;
|
||||
return e.bounds;
|
||||
}
|
||||
let b = match &a.kind {
|
||||
NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } if !fx::has_object_fx(a) => {
|
||||
let mut acc: Option<Rect> = None;
|
||||
// An Image Trace object's hidden source image shows in some of its views.
|
||||
let source = a.extras().trace.is_some().then(|| children.first()).flatten();
|
||||
for c in children {
|
||||
if c.visible || source.is_some_and(|s| Arc::ptr_eq(s, c)) {
|
||||
acc = vectorcraft_geom::union_opt(acc, self.bounds_of(symbols, c));
|
||||
}
|
||||
}
|
||||
acc
|
||||
}
|
||||
_ => brush_fx::cull_bounds(symbols, a),
|
||||
};
|
||||
self.geom.insert(key, GeomEntry { node: a.clone(), bounds: b, path: None, stamp: self.stamp });
|
||||
b
|
||||
}
|
||||
|
||||
/// Drop the cached bounds of symbol instances and of the objects that hold them when `doc`'s
|
||||
/// symbols are not those of the document last drawn (by name and art): those bounds measured
|
||||
/// the instances by their symbol's art.
|
||||
pub(crate) fn check_symbols(&mut self, doc: &Document) {
|
||||
let same = self.symbols.len() == doc.symbols.len()
|
||||
&& self.symbols.iter().zip(&doc.symbols).all(|((name, art), s)| *name == s.name && std::ptr::eq(art.as_ptr(), Arc::as_ptr(&s.art)));
|
||||
if !same {
|
||||
self.geom.retain(|_, e| !holds_instance(&e.node));
|
||||
self.symbols = doc.symbols.iter().map(|s| (s.name.clone(), Arc::downgrade(&s.art))).collect();
|
||||
}
|
||||
}
|
||||
|
||||
/// When a plug-in has been installed or removed since the last check
|
||||
/// ([`effects::plugin_revision`]), drop what the caches keep from plug-in effects: the effect
|
||||
/// geometry of paths with a plug-in effect, the cull bounds of objects that have one or hold one,
|
||||
/// of symbol instances and of the objects that hold them, and the art drawn for the effects of
|
||||
/// objects with a plug-in effect. Rasters of raster effects and evaluations of live objects hold
|
||||
/// the revision in their keys when what they draw has a plug-in effect (`fx::Inputs`,
|
||||
/// `live::resources_key`).
|
||||
pub(crate) fn check_plugins(&mut self) {
|
||||
let revision = effects::plugin_revision();
|
||||
if revision == self.plugin_revision {
|
||||
return;
|
||||
}
|
||||
self.plugin_revision = revision;
|
||||
self.fx_geom.retain(|_, e| !effects::has_plugin_effect(&e.node));
|
||||
self.geom.retain(|_, e| !holds_plugin_effect(&e.node) && !holds_instance(&e.node));
|
||||
self.fx_arts.retain(|(node, ..)| !effects::has_plugin_effect(node));
|
||||
}
|
||||
|
||||
/// Cached region a clip group's clipping path `a` clips to ([`effects::clip_outline`]):
|
||||
/// outlining text and uniting shapes is too slow to repeat every frame.
|
||||
pub(crate) fn clip_of(&mut self, a: &Arc<Node>) -> Option<Arc<(BezPath, FillRule)>> {
|
||||
let key = Arc::as_ptr(a) as usize;
|
||||
if let Some((node, region)) = self.clips.get(&key, self.stamp)
|
||||
&& Arc::ptr_eq(node, a)
|
||||
{
|
||||
return region.clone();
|
||||
}
|
||||
let region = effects::clip_outline(a).map(Arc::new);
|
||||
let bytes = size_of::<ClipEntry>() + region.as_ref().map_or(0, |r| lru::path_bytes(&r.0));
|
||||
self.clips.insert(key, (a.clone(), region.clone()), bytes, self.stamp);
|
||||
region
|
||||
}
|
||||
|
||||
/// Cached fills and strokes of clipping path `a` ([`Node::clip_paint`]): the parts keep their
|
||||
/// allocations between frames, so their own geometry stays cached.
|
||||
fn clip_paint_of(&mut self, a: &Arc<Node>) -> (Option<Arc<Node>>, Option<Arc<Node>>) {
|
||||
let key = Arc::as_ptr(a) as usize;
|
||||
if let Some((node, fill, stroke)) = self.clip_paints.get(&key, self.stamp)
|
||||
&& Arc::ptr_eq(node, a)
|
||||
{
|
||||
return (fill.clone(), stroke.clone());
|
||||
}
|
||||
let paint = a.clip_paint();
|
||||
let (fill, stroke) = (paint.fill.map(Arc::new), paint.stroke.map(Arc::new));
|
||||
let bytes = size_of::<ClipPaintEntry>() + [&fill, &stroke].iter().filter_map(|p| p.as_deref()).map(lru::node_bytes).sum::<usize>();
|
||||
self.clip_paints.insert(key, (a.clone(), fill.clone(), stroke.clone()), bytes, self.stamp);
|
||||
(fill, stroke)
|
||||
}
|
||||
|
||||
/// Cached BezPath of a path or compound path node (its bounds cached with it, see
|
||||
/// [`Self::bounds_of`]).
|
||||
fn path_of(&mut self, symbols: &SymbolBoxes, a: &Arc<Node>) -> Option<Arc<BezPath>> {
|
||||
let key = Arc::as_ptr(a) as usize;
|
||||
if let Some(e) = self.geom.get(&key)
|
||||
&& Arc::ptr_eq(&e.node, a)
|
||||
&& let Some(p) = &e.path
|
||||
{
|
||||
return Some(p.clone());
|
||||
}
|
||||
let p = Arc::new(a.stroke_path()?);
|
||||
let bounds = self.bounds_of(symbols, a);
|
||||
self.geom.insert(key, GeomEntry { node: a.clone(), bounds, path: Some(p.clone()), stamp: self.stamp });
|
||||
Some(p)
|
||||
}
|
||||
|
||||
/// The cached path of path or compound path `n` ([`Self::path_of`]) when the frame is in
|
||||
/// Outline view and `n` is `fx_owner`, else `None`.
|
||||
fn outline_path(&mut self, f: &Frame, n: &Node) -> Option<Arc<BezPath>> {
|
||||
let owner = self.fx_owner.as_ref().filter(|o| f.opts.outline && std::ptr::eq(&***o, n)).cloned()?;
|
||||
self.path_of(f.symbols, &owner)
|
||||
}
|
||||
|
||||
/// Whether `a` is left out of this frame: hidden, a skipped template or guide, or culled.
|
||||
fn skipped(&mut self, f: &Frame, a: &Arc<Node>) -> bool {
|
||||
let skipped_view_item = (f.opts.skip_templates || f.opts.hide_templates) && matches!(a.kind, NodeKind::Layer { template: true, .. })
|
||||
|| (f.opts.skip_templates || f.opts.hide_guides) && matches!(a.kind, NodeKind::Path { guide: true, .. });
|
||||
if !a.visible || skipped_view_item || f.opts.hidden.contains(&a.id) {
|
||||
return true;
|
||||
}
|
||||
match self.bounds_of(f.symbols, a) {
|
||||
Some(b) => {
|
||||
let pad = f.px * 2.0;
|
||||
// Level of detail: leaves smaller than a quarter pixel are invisible.
|
||||
let culled =
|
||||
!rects_overlap(b.inflate(pad, pad), f.visible) || (!a.is_container() && b.width() < f.px * 0.25 && b.height() < f.px * 0.25);
|
||||
self.stats.culled += culled as usize;
|
||||
culled
|
||||
}
|
||||
None => !a.is_container(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn draw_arc(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc<Node>) {
|
||||
if self.skipped(f, a) {
|
||||
return;
|
||||
}
|
||||
if let Some(m) = a.extras().mask.as_deref()
|
||||
&& !m.disabled
|
||||
&& !f.opts.outline
|
||||
&& !self.is_shape(a)
|
||||
{
|
||||
// A masked object is a non-isolated group of its own, drawn over its own pixels: the
|
||||
// mask is rendered over those only.
|
||||
let bounds = self.bounds_of(f.symbols, a);
|
||||
let Some((r, sub)) = group::area(ctx, f, bounds) else { return };
|
||||
let mask = Some(self.mask_values(&sub, m, r.w, r.h));
|
||||
let blends = a.blend != vectorcraft_color::BlendMode::Normal || (!a.isolate && self.blends_through(a));
|
||||
self.group(ctx, f, Composite { mask, blends, bounds, ..Default::default() }, &mut |r, c, fr| r.draw_arc_body(c, fr, a));
|
||||
return;
|
||||
}
|
||||
self.draw_arc_body(ctx, f, a);
|
||||
}
|
||||
|
||||
/// The coverage of opacity mask `m` per output pixel (row-major): its art rendered offscreen,
|
||||
/// as luminance ([`mask_value`]).
|
||||
pub(super) fn mask_values(&mut self, f: &Frame, m: &vectorcraft_doc::OpacityMask, w: u16, h: u16) -> Vec<u8> {
|
||||
let mut mctx = f.offscreen_context(w, h);
|
||||
// Mask art is a picture of its own: it takes no part in a knockout group around the object,
|
||||
// and its luminance is that of its screen colours.
|
||||
let outer = (
|
||||
std::mem::take(&mut self.knockout),
|
||||
std::mem::take(&mut self.nested),
|
||||
self.backdrop.take(),
|
||||
std::mem::take(&mut self.clip_paths),
|
||||
self.picture.take(),
|
||||
);
|
||||
self.draw_kept_node(&mut mctx, &Frame { mt: false, ink: Ink::Display, ..*f }, &m.art);
|
||||
let pm = self.finish(&mut mctx, self.raster);
|
||||
(self.knockout, self.nested, self.backdrop, self.clip_paths, self.picture) = outer;
|
||||
pm.data().iter().map(|p| mask_value(p.r, p.g, p.b, p.a, m.clip, m.invert)).collect()
|
||||
}
|
||||
|
||||
/// Everything [`Self::draw_arc`] does after culling.
|
||||
fn draw_arc_body(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc<Node>) {
|
||||
// Fast path for plain paths: cached geometry, opacity folded into the paint.
|
||||
// A blend mode on a single plain fill applies per draw (exact for one paint operation);
|
||||
// a blend layer would composite the whole viewport.
|
||||
let blended = a.blend != vectorcraft_color::BlendMode::Normal;
|
||||
if let NodeKind::Path { rule, guide: false, .. } = &a.kind
|
||||
&& !f.opts.outline
|
||||
&& (!blended || single_plain_fill(a))
|
||||
&& !a.isolate
|
||||
&& !fx::has_fx(a)
|
||||
&& (self.opacity_of(a) >= 1.0 || painted_items(a) == 1)
|
||||
&& let Some(bp) = self.path_of(f.symbols, a)
|
||||
{
|
||||
self.alpha = self.opacity_of(a).clamp(0.0, 1.0);
|
||||
self.cur = Some(a.clone());
|
||||
if blended {
|
||||
ctx.set_blend_mode(blend_mode(a.blend));
|
||||
}
|
||||
self.draw_shape(ctx, f, a, &bp, *rule);
|
||||
if blended {
|
||||
ctx.set_blend_mode(blend_mode(vectorcraft_color::BlendMode::Normal));
|
||||
}
|
||||
self.cur = None;
|
||||
self.alpha = 1.0;
|
||||
self.stats.drawn += 1;
|
||||
return;
|
||||
}
|
||||
if fx::has_object_fx(a) {
|
||||
return self.draw_object_fx(ctx, f, a, true);
|
||||
}
|
||||
if let NodeKind::Text(t) = &a.kind
|
||||
&& self.opacity_of(a) >= 1.0
|
||||
&& a.blend == vectorcraft_color::BlendMode::Normal
|
||||
&& !fx::has_fx(a)
|
||||
{
|
||||
let t = &*f.doc.inline_resolved(t);
|
||||
let (g, kept) = match f.text_snap(t) {
|
||||
Some(xf) => (Arc::new(text_geom_snapped(t, Some(xf))), false),
|
||||
None => self.text_geom_of(a, t),
|
||||
};
|
||||
self.draw_text_geom(ctx, f, a, t, &g, kept);
|
||||
self.stats.drawn += 1;
|
||||
return;
|
||||
}
|
||||
if vectorcraft_doc::live::is_live(a) || effects::has_pathfinder(a) {
|
||||
return self.draw_live(ctx, f, a);
|
||||
}
|
||||
// Its live-effect geometry depends on the node alone, and for plug-in effects on the
|
||||
// plug-ins installed (`check_plugins`), so it can be kept across frames.
|
||||
let outer = self.fx_owner.replace(a.clone());
|
||||
self.draw_node(ctx, f, a, true);
|
||||
self.fx_owner = outer;
|
||||
}
|
||||
|
||||
pub(crate) fn draw_node(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, force: bool) {
|
||||
if !force && (!n.visible || f.opts.hidden.contains(&n.id)) {
|
||||
return;
|
||||
}
|
||||
// A cancelled export stops drawing; whoever asked for the picture drops it (see `cancel`).
|
||||
if vectorcraft_doc::cancel::is_cancelled() {
|
||||
return;
|
||||
}
|
||||
if force {
|
||||
// Bounds were already checked by draw_arc (or the caller wants it drawn regardless).
|
||||
} else if let Some(b) = fx::cull_bounds(f.symbols, n) {
|
||||
let pad = f.px * 2.0;
|
||||
if !rects_overlap(b.inflate(pad, pad), f.visible) {
|
||||
self.stats.culled += n.count();
|
||||
return;
|
||||
}
|
||||
} else if !n.is_container() {
|
||||
return;
|
||||
}
|
||||
// Layer Options on screen: a layer whose Preview is off draws in outline, and Dim Images
|
||||
// fades its images, a template's too (exports and thumbnails, which leave templates out,
|
||||
// ignore both).
|
||||
if let NodeKind::Layer { preview, dim_images, template, .. } = &n.kind
|
||||
&& f.opts.dim_templates
|
||||
&& !f.opts.skip_templates
|
||||
{
|
||||
// A template layer stays in Preview while the view is in Outline (and whatever its own
|
||||
// Preview option says): its picture is there to be traced (#1486).
|
||||
if *template && f.opts.outline {
|
||||
let opts = RenderOptions { outline: false, ..f.opts.clone() };
|
||||
return self.draw_node(ctx, &Frame { opts: &opts, ..*f }, n, force);
|
||||
}
|
||||
if !preview && !template && !f.opts.outline {
|
||||
let opts = RenderOptions { outline: true, ..f.opts.clone() };
|
||||
return self.draw_node(ctx, &Frame { opts: &opts, ..*f }, n, force);
|
||||
}
|
||||
if let Some(p) = *dim_images {
|
||||
let outer = self.dim_images;
|
||||
let dim = f32::from(p).clamp(0.0, 100.0) / 100.0;
|
||||
self.dim_images = Some(outer.map_or(dim, |o| o.min(dim)));
|
||||
self.draw_layer_node(ctx, f, n);
|
||||
self.dim_images = outer;
|
||||
return;
|
||||
}
|
||||
}
|
||||
self.draw_layer_node(ctx, f, n);
|
||||
}
|
||||
|
||||
/// [`Self::draw_node`] after culling and Layer Options.
|
||||
fn draw_layer_node(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node) {
|
||||
// Isolation mode: the art around the isolated container draws dimmed (#833).
|
||||
if let Some((isolated, path)) = self.isolation_path(f) {
|
||||
// A container on the way down to it draws as usual: its members decide.
|
||||
if path.contains(&n.id) && n.id != isolated {
|
||||
return self.draw_layer_node_now(ctx, f, n);
|
||||
}
|
||||
self.isolation_settled = true;
|
||||
if n.id == isolated {
|
||||
self.draw_layer_node_now(ctx, f, n);
|
||||
} else {
|
||||
self.dimmed(ctx, f, &mut |r, c, fr| r.draw_layer_node_now(c, fr, n));
|
||||
}
|
||||
self.isolation_settled = false;
|
||||
return;
|
||||
}
|
||||
self.draw_layer_node_now(ctx, f, n);
|
||||
}
|
||||
|
||||
/// In isolation mode, while drawing outside the isolated container and the art dimmed around
|
||||
/// it: the isolated container and its layers and groups, from the top layer down to it.
|
||||
pub(crate) fn isolation_path(&mut self, f: &Frame) -> Option<(NodeId, Vec<NodeId>)> {
|
||||
// Opacity-mask editing isolates the temporary layer for tools; that layer is not painted on
|
||||
// the page (the mask applies on the object), so canvas dimming would wash out everything.
|
||||
let isolated = f.opts.isolated.filter(|_| f.doc.mask_edit.is_none() && !self.isolation_settled)?;
|
||||
let doc = std::ptr::from_ref(f.doc) as usize;
|
||||
if self.isolation.as_ref().is_none_or(|(stamp, d, id, _)| (*stamp, *d, *id) != (self.stamp, doc, isolated)) {
|
||||
self.isolation = Some((self.stamp, doc, isolated, f.doc.ancestry(isolated).unwrap_or_default()));
|
||||
}
|
||||
let path = self.isolation.as_ref().map(|(.., path)| path.clone()).filter(|p| !p.is_empty())?;
|
||||
Some((isolated, path))
|
||||
}
|
||||
|
||||
/// `draw` at [`ISOLATION_DIM`], with nothing inside dimmed again.
|
||||
fn dimmed(&mut self, ctx: &mut RenderContext, f: &Frame, draw: &mut group::Content) {
|
||||
let settled = std::mem::replace(&mut self.isolation_settled, true);
|
||||
let comp = Composite { opacity: ISOLATION_DIM, ..Default::default() };
|
||||
self.group(ctx, f, comp, draw);
|
||||
self.isolation_settled = settled;
|
||||
}
|
||||
|
||||
/// [`Self::draw_layer_node`] past isolation mode's dimming.
|
||||
fn draw_layer_node_now(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node) {
|
||||
if fx::has_object_fx(n) {
|
||||
return self.draw_object_fx(ctx, f, &Arc::new(n.clone()), false);
|
||||
}
|
||||
let outline = f.opts.outline;
|
||||
let opacity = self.opacity_of(n);
|
||||
// Whether this container's children knock each other out.
|
||||
let knockout = !outline && n.knocks_out(self.knockout);
|
||||
let enclosing = std::mem::replace(&mut self.knockout, knockout);
|
||||
if !outline && (opacity < 1.0 || n.blend != vectorcraft_color::BlendMode::Normal || n.isolate || knockout) {
|
||||
let blends = self.blends_through(n);
|
||||
let bounds = if blends { self.node_bounds(f.symbols, n) } else { None };
|
||||
let comp = Composite { blend: n.blend, opacity, isolated: n.isolate, blends, bounds, ..Default::default() };
|
||||
self.group(ctx, f, comp, &mut |r, c, fr| r.draw_content(c, fr, n, knockout));
|
||||
} else {
|
||||
self.draw_content(ctx, f, n, knockout);
|
||||
}
|
||||
self.knockout = enclosing;
|
||||
self.stats.drawn += 1;
|
||||
}
|
||||
|
||||
/// What `n` draws inside its transparency group (`knockout`: its children knock each other out).
|
||||
fn draw_content(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, knockout: bool) {
|
||||
match &n.kind {
|
||||
NodeKind::Group { children, clip: false } if f.opts.trace_views && !f.opts.outline && Self::trace_view(f, n) != TraceView::Result => {
|
||||
self.draw_trace_view(ctx, f, children, Self::trace_view(f, n), knockout)
|
||||
}
|
||||
NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
|
||||
self.draw_children(ctx, f, children, knockout)
|
||||
}
|
||||
NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } if f.opts.outline => {
|
||||
for c in children {
|
||||
self.draw_outline_member(ctx, f, c);
|
||||
}
|
||||
}
|
||||
NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {
|
||||
// Nothing to clip by hides the clipped art (as in the SVG and PDF output). A clip
|
||||
// group doesn't isolate: blending inside it reaches the art below. The clipping
|
||||
// path's fill paints behind the clipped art and its stroke over it, unclipped.
|
||||
if let Some((clip, rest)) = children.split_first()
|
||||
&& let Some(region) = self.clip_of(clip)
|
||||
{
|
||||
let (fill, stroke) = self.clip_paint_of(clip);
|
||||
// An image inside its own frame painted straight into the clipping path, without
|
||||
// a clip layer (envelopes cut distorted images into many such pieces).
|
||||
if let ([image], None, None) = (rest, &fill, &stroke)
|
||||
&& let NodeKind::Image(im) = &image.kind
|
||||
&& plain_image(image, im, ®ion.0)
|
||||
{
|
||||
self.draw_image_in(ctx, f, im, Some(®ion));
|
||||
self.stats.drawn += 1;
|
||||
return;
|
||||
}
|
||||
let blends = self.blends_through(n);
|
||||
let bounds = if blends { Some(region.0.bounding_box()) } else { None };
|
||||
let comp = Composite { clip: Some((®ion.0, region.1)), blends, bounds, ..Default::default() };
|
||||
self.group(ctx, f, comp, &mut |r, c, fr| {
|
||||
if let Some(fill) = &fill {
|
||||
r.draw_arc(c, fr, fill);
|
||||
}
|
||||
r.draw_children(c, fr, rest, knockout)
|
||||
});
|
||||
if let Some(stroke) = &stroke {
|
||||
self.draw_arc(ctx, f, stroke);
|
||||
}
|
||||
}
|
||||
}
|
||||
NodeKind::Path { path, rule, guide, .. } => {
|
||||
let bp = self.outline_path(f, n).unwrap_or_else(|| Arc::new(path.to_bezpath()));
|
||||
if *guide {
|
||||
let ([r, g, b], dots) = f.opts.guide;
|
||||
let mut screen = BezPath::clone(&bp);
|
||||
screen.apply_affine(f.view);
|
||||
// The rasterizer makes every dash of the whole path before clipping: a guide
|
||||
// running far off screen (from a file) asked for millions of them. Past
|
||||
// [`MAX_GUIDE_DASHES`] (by its control polygon, which is at least as long) it
|
||||
// is drawn solid.
|
||||
let h = self.hairline;
|
||||
if dots && polygon_length(&screen) / (4.0 * h) <= MAX_GUIDE_DASHES {
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
ctx.set_stroke(kurbo::Stroke::new(1.5 * h).with_dashes(0.0, [1.5 * h, 2.5 * h]));
|
||||
ctx.set_paint(f.ink.fixed([r, g, b, 255]));
|
||||
ctx.stroke_path(&screen);
|
||||
} else {
|
||||
self.hairline(ctx, f, &bp, [r, g, b, 255]);
|
||||
}
|
||||
} else {
|
||||
self.draw_shape(ctx, f, n, &bp, *rule);
|
||||
}
|
||||
}
|
||||
NodeKind::Compound { children, rule } => {
|
||||
if let Some(bp) = self.outline_path(f, n) {
|
||||
return self.draw_shape(ctx, f, n, &bp, *rule);
|
||||
}
|
||||
let mut bp = BezPath::new();
|
||||
for c in children {
|
||||
if let Some(p) = c.path_data() {
|
||||
bp.extend(p.to_bezpath());
|
||||
}
|
||||
}
|
||||
self.draw_shape(ctx, f, n, &bp, *rule);
|
||||
}
|
||||
NodeKind::Text(t) => self.draw_text(ctx, f, n, t),
|
||||
NodeKind::Image(im) => self.draw_image(ctx, f, im),
|
||||
NodeKind::SymbolInstance { symbol, xf } => {
|
||||
if let Some(sym) = f.doc.symbols.iter().find(|s| &s.name == symbol)
|
||||
&& self.charge_symbol(&sym.art)
|
||||
{
|
||||
let (art, kept) = self.placed_art(&sym.art, *xf, false, Some(n));
|
||||
self.draw_placed_art(ctx, f, &art, kept);
|
||||
}
|
||||
}
|
||||
NodeKind::Blend { .. }
|
||||
| NodeKind::Envelope { .. }
|
||||
| NodeKind::Mesh(_)
|
||||
| NodeKind::Repeat(_)
|
||||
| NodeKind::PlacedDocument(_)
|
||||
| NodeKind::Intertwine { .. } => match self.live_root.clone().filter(|a| std::ptr::eq(&**a, n)) {
|
||||
Some(a) => self.draw_live_body(ctx, f, &a, true),
|
||||
None => self.draw_live_node(ctx, f, n),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Count symbol art `art`'s objects against the frame's [`vectorcraft_doc::MAX_SYMBOL_NODES`]: `false` (the
|
||||
/// instance isn't drawn) once they would pass it.
|
||||
fn charge_symbol(&mut self, art: &Node) -> bool {
|
||||
let total = self.symbol_nodes.saturating_add(art.count() as u64);
|
||||
(total <= vectorcraft_doc::MAX_SYMBOL_NODES).then(|| self.symbol_nodes = total).is_some()
|
||||
}
|
||||
|
||||
/// Draw symbol art `art` as [`Self::placed_art`] placed it for an instance or an inline graphic
|
||||
/// (`kept`: kept between frames, see [`Self::draw_kept_node`]).
|
||||
pub(super) fn draw_placed_art(&mut self, ctx: &mut RenderContext, f: &Frame, art: &Arc<Node>, kept: bool) {
|
||||
let outer = std::mem::replace(&mut self.made_again, !kept);
|
||||
if kept {
|
||||
self.draw_kept_node(ctx, f, art);
|
||||
} else {
|
||||
self.draw_node(ctx, f, art, true);
|
||||
}
|
||||
self.made_again = outer;
|
||||
}
|
||||
|
||||
/// [`Self::draw_node`] of `a` (drawn whatever its visibility and bounds), whose `Arc` stays the
|
||||
/// same from frame to frame while the art does. When `a` is a live object,
|
||||
/// [`Self::draw_content`] draws its evaluation from the live cache ([`Self::live_root`]).
|
||||
pub(crate) fn draw_kept_node(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc<Node>) {
|
||||
let live = vectorcraft_doc::live::is_live(a).then(|| a.clone());
|
||||
let outer = std::mem::replace(&mut self.live_root, live);
|
||||
self.draw_node(ctx, f, a, true);
|
||||
self.live_root = outer;
|
||||
}
|
||||
|
||||
/// The View `n` draws with on screen: Source Image when it is an Image Trace object listed in
|
||||
/// [`RenderOptions::trace_source`], else its own.
|
||||
fn trace_view(f: &Frame, n: &Node) -> TraceView {
|
||||
match &f.opts.trace_source {
|
||||
Some(ids) if n.extras().trace.is_some() && ids.contains(&n.id) => TraceView::Source,
|
||||
_ => n.trace_view(),
|
||||
}
|
||||
}
|
||||
|
||||
/// An Image Trace object's `children` (the hidden source image, then the traced shapes) as
|
||||
/// `view` shows them on screen.
|
||||
fn draw_trace_view(&mut self, ctx: &mut RenderContext, f: &Frame, children: &[Arc<Node>], view: TraceView, knockout: bool) {
|
||||
let Some((source, shapes)) = children.split_first() else { return };
|
||||
if view.shows_source() && matches!(source.kind, NodeKind::Image(_)) {
|
||||
self.draw_node(ctx, f, source, true);
|
||||
}
|
||||
if view.shows_result() {
|
||||
self.draw_children(ctx, f, shapes, knockout);
|
||||
}
|
||||
if view.shows_outlines() {
|
||||
let opts = RenderOptions { outline: true, ..f.opts.clone() };
|
||||
let frame = Frame { opts: &opts, ..*f };
|
||||
for c in shapes {
|
||||
self.draw_outline_member(ctx, &frame, c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Self::draw_node`] for `c`, a member of a clip group or a shape of an Image Trace object in
|
||||
/// Outline view, culled by its cached bounds ([`Self::bounds_of`]) and drawn with `c` as
|
||||
/// `fx_owner`, so its path, its live-effect geometry and, through [`Self::draw_kept_node`], a
|
||||
/// live object's evaluation come from the caches.
|
||||
fn draw_outline_member(&mut self, ctx: &mut RenderContext, f: &Frame, c: &Arc<Node>) {
|
||||
if !c.visible || f.opts.hidden.contains(&c.id) || f.opts.hide_guides && matches!(c.kind, NodeKind::Path { guide: true, .. }) {
|
||||
return;
|
||||
}
|
||||
match self.bounds_of(f.symbols, c) {
|
||||
Some(b) => {
|
||||
let pad = f.px * 2.0;
|
||||
if !rects_overlap(b.inflate(pad, pad), f.visible) {
|
||||
self.stats.culled += c.count();
|
||||
return;
|
||||
}
|
||||
}
|
||||
None if !c.is_container() => return,
|
||||
None => {}
|
||||
}
|
||||
let outer = self.fx_owner.replace(c.clone());
|
||||
self.draw_kept_node(ctx, f, c);
|
||||
self.fx_owner = outer;
|
||||
}
|
||||
|
||||
/// The children of a group: as the elements of a knockout group when `knockout`.
|
||||
pub(super) fn draw_children(&mut self, ctx: &mut RenderContext, f: &Frame, children: &[Arc<Node>], knockout: bool) {
|
||||
if knockout {
|
||||
self.draw_knockout(ctx, f, children);
|
||||
} else if let Some((_, path)) = self.isolation_path(f) {
|
||||
// Isolation mode, in a container on the way down to the isolated one: each run of
|
||||
// members around it draws dimmed as one (#833).
|
||||
let mut rest = children;
|
||||
while let Some(i) = rest.iter().position(|c| path.contains(&c.id)) {
|
||||
let (around, from) = rest.split_at(i);
|
||||
if !around.is_empty() {
|
||||
self.dimmed(ctx, f, &mut |r, c, fr| around.iter().for_each(|n| r.draw_arc(c, fr, n)));
|
||||
}
|
||||
let Some((on_path, after)) = from.split_first() else { break };
|
||||
self.draw_arc(ctx, f, on_path);
|
||||
rest = after;
|
||||
}
|
||||
if !rest.is_empty() {
|
||||
self.dimmed(ctx, f, &mut |r, c, fr| rest.iter().for_each(|n| r.draw_arc(c, fr, n)));
|
||||
}
|
||||
} else {
|
||||
for c in children {
|
||||
self.draw_arc(ctx, f, c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Cull bounds of `n` (symbol instances measured by their art box from `symbols`): cached when
|
||||
/// it is a node of the tree being drawn.
|
||||
fn node_bounds(&mut self, symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
|
||||
match self.geom.get(&(n as *const Node as usize)) {
|
||||
// The entry keeps its node alive, so the address is that node's.
|
||||
Some(e) if std::ptr::eq(Arc::as_ptr(&e.node), n) => e.bounds,
|
||||
_ => fx::cull_bounds(symbols, n),
|
||||
}
|
||||
}
|
||||
|
||||
/// The children of a knockout group ([`Node::knockout_elements`]). Each element first erases
|
||||
/// what the elements below it drew wherever it paints (its knockout shape: its coverage at full
|
||||
/// object opacity without its opacity mask, or as drawn when its opacity and mask define the
|
||||
/// knockout shape), then adds itself: it composites against the group's backdrop instead of
|
||||
/// over the elements below it (the art below the group when the group is non-isolated and
|
||||
/// drawn over a copy of it, see [`Self::group`] and [`Self::knockout_over`]).
|
||||
pub(crate) fn draw_knockout(&mut self, ctx: &mut RenderContext, f: &Frame, children: &[Arc<Node>]) {
|
||||
let backdrop = self.backdrop.take();
|
||||
for c in Node::knockout_elements(children) {
|
||||
if self.skipped(f, c) {
|
||||
continue;
|
||||
}
|
||||
self.knockout_pass(ctx, f, c, Compose::DestOut);
|
||||
match &backdrop {
|
||||
Some(b) => self.knockout_over(ctx, f, c, b),
|
||||
None => self.knockout_pass(ctx, f, c, Compose::Plus),
|
||||
}
|
||||
}
|
||||
self.backdrop = backdrop;
|
||||
}
|
||||
|
||||
/// Whether `n` is the knockout element being drawn as its shape (see [`Self::draw_knockout`]).
|
||||
pub(super) fn is_shape(&self, n: &Node) -> bool {
|
||||
self.shape_of == n as *const Node as usize
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
use super::*;
|
||||
use crate::paint;
|
||||
|
||||
impl Renderer {
|
||||
/// The object opacity `n` is drawn with (full while it is drawn as its knockout shape).
|
||||
pub(crate) fn opacity_of(&self, n: &Node) -> f32 {
|
||||
if self.is_shape(n) { 1.0 } else { n.opacity }
|
||||
}
|
||||
|
||||
pub(crate) fn hairline(&mut self, ctx: &mut RenderContext, f: &Frame, bp: &BezPath, rgba: [u8; 4]) {
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
let mut screen = bp.clone();
|
||||
screen.apply_affine(f.view);
|
||||
ctx.set_stroke(kurbo::Stroke::new(self.hairline));
|
||||
ctx.set_paint(f.ink.fixed(rgba));
|
||||
ctx.stroke_path(&screen);
|
||||
}
|
||||
|
||||
pub(super) fn draw_shape(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, bp: &BezPath, rule: FillRule) {
|
||||
if !drawable(bp, f.view, n) {
|
||||
return;
|
||||
}
|
||||
if fx::has_fx(n) {
|
||||
return self.draw_shape_fx(ctx, f, n, bp, rule);
|
||||
}
|
||||
if f.opts.outline {
|
||||
self.hairline(ctx, f, bp, [0, 0, 0, 255]);
|
||||
return;
|
||||
}
|
||||
// Bounds only matter to gradients and patterns (their geometry is relative to the object).
|
||||
let solid = |p: &vectorcraft_color::Paint| matches!(p, vectorcraft_color::Paint::Solid { .. } | vectorcraft_color::Paint::None);
|
||||
let needs_bounds = n.appearance.items.iter().any(|i| match i {
|
||||
AppearanceItem::Fill(fl) => !solid(&fl.paint),
|
||||
AppearanceItem::Stroke(st) => !solid(&st.paint),
|
||||
});
|
||||
let bounds = if needs_bounds { bp.bounding_box() } else { Rect::ZERO };
|
||||
for item in &n.appearance.items {
|
||||
match item {
|
||||
AppearanceItem::Fill(fl) => {
|
||||
if !fl.visible || fl.paint.is_none() {
|
||||
continue;
|
||||
}
|
||||
let layered = fl.opacity < 1.0 || fl.blend != vectorcraft_color::BlendMode::Normal;
|
||||
if layered {
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
ctx.push_layer(None, Some(blend_mode(fl.blend)), Some(fl.opacity), None, None);
|
||||
}
|
||||
ctx.set_transform(f.view);
|
||||
if paint::set_fill_paint(ctx, &fl.paint, bounds, f) {
|
||||
self.fold_alpha(ctx, f.ink, &fl.paint);
|
||||
ctx.set_fill_rule(fill_rule(rule));
|
||||
ctx.fill_path(bp);
|
||||
}
|
||||
if layered {
|
||||
ctx.pop_layer();
|
||||
}
|
||||
}
|
||||
AppearanceItem::Stroke(st) => {
|
||||
if !st.visible || st.paint.is_none() || st.width <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
if st.brush.is_some() && self.draw_brush(ctx, f, n, bp, st) {
|
||||
continue;
|
||||
}
|
||||
self.draw_stroke(ctx, f, Affine::IDENTITY, bp, rule, st, None, bounds);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Multiply the folded object opacity into a solid paint.
|
||||
pub(super) fn fold_alpha(&self, ctx: &mut RenderContext, ink: Ink, p: &vectorcraft_color::Paint) {
|
||||
if self.alpha < 1.0
|
||||
&& let vectorcraft_color::Paint::Solid { color, .. } = p
|
||||
{
|
||||
ctx.set_paint(ink.color(color, self.alpha));
|
||||
}
|
||||
}
|
||||
|
||||
/// Paint stroke `st` of the shape `bp` (in the space `xf` maps to the document; `bounds`: its
|
||||
/// geometric bounds there) with its alignment, dashes, profile, arrowheads, opacity and blend.
|
||||
/// `chars` is the glyph geometry kept in `texts` and the run that `st` is the character stroke
|
||||
/// of, when it is one.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn draw_stroke(
|
||||
&mut self,
|
||||
ctx: &mut RenderContext,
|
||||
f: &Frame,
|
||||
xf: Affine,
|
||||
bp: &BezPath,
|
||||
rule: FillRule,
|
||||
st: &StrokeLayer,
|
||||
chars: Option<(&Arc<TextGeom>, usize)>,
|
||||
bounds: Rect,
|
||||
) {
|
||||
let pieces = effects::stroke::stroke_pieces(bp, st);
|
||||
// The line and its heads overlap: they take the opacity once, in one layer, instead of
|
||||
// each folding it into its paint.
|
||||
let folded = if pieces.heads.is_empty() { 1.0 } else { std::mem::replace(&mut self.alpha, 1.0) };
|
||||
let opacity = st.opacity * folded;
|
||||
let layered = opacity < 1.0 || st.blend != vectorcraft_color::BlendMode::Normal || st.align == StrokeAlign::Outside;
|
||||
if layered {
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
ctx.push_layer(None, Some(blend_mode(st.blend)), Some(opacity), None, None);
|
||||
}
|
||||
ctx.set_transform(f.view * xf);
|
||||
let closed = effects::stroke::is_closed(bp);
|
||||
// Keep hairlines visible when zoomed far out (at least ~1 device pixel).
|
||||
let width = effects::stroke::aligned_width(st, closed).max(f.px * 0.5 / xf.determinant().abs().sqrt().max(1e-9));
|
||||
let inside = st.align == StrokeAlign::Inside && closed;
|
||||
if inside {
|
||||
ctx.set_fill_rule(fill_rule(rule));
|
||||
ctx.push_clip_layer(bp);
|
||||
}
|
||||
// One paint box for the line and the heads, so a gradient runs on into the heads.
|
||||
let paint_bounds = bounds.inflate(st.width / 2.0, st.width / 2.0);
|
||||
if let Some(g) = st.path_gradient() {
|
||||
self.fill_path_gradient(ctx, f, bp, rule, st, chars, &pieces, width, &g.gradient);
|
||||
} else if paint::set_paint(ctx, &st.paint, paint_bounds, f) {
|
||||
self.fold_alpha(ctx, f.ink, &st.paint);
|
||||
ctx.set_fill_rule(peniko::Fill::NonZero);
|
||||
match self.cached_stroke(f, chars, &pieces.line, st, width) {
|
||||
Some(o) => ctx.fill_path(&o),
|
||||
None => ctx.fill_path(&effects::stroke::line_outline(&pieces.line, st, width, f.px * 0.25)),
|
||||
}
|
||||
for head in &pieces.heads {
|
||||
ctx.fill_path(&head.outline);
|
||||
}
|
||||
}
|
||||
if inside {
|
||||
ctx.pop_layer();
|
||||
}
|
||||
if st.align == StrokeAlign::Outside && closed {
|
||||
// Punch out the interior.
|
||||
ctx.set_blend_mode(BlendMode::new(Mix::Normal, Compose::DestOut));
|
||||
ctx.set_paint(peniko::Color::BLACK);
|
||||
ctx.set_fill_rule(fill_rule(rule));
|
||||
ctx.fill_path(bp);
|
||||
ctx.set_blend_mode(BlendMode::default());
|
||||
}
|
||||
if layered {
|
||||
ctx.pop_layer();
|
||||
}
|
||||
if !pieces.heads.is_empty() {
|
||||
self.alpha = folded;
|
||||
}
|
||||
}
|
||||
|
||||
/// Paint the line and arrowheads (`pieces`) of stroke `st` of `bp` (filled with `rule`) with
|
||||
/// its gradient `g` laid along or across the path ([`effects::stroke::gradient_slices`]). Each
|
||||
/// piece clips the slices, grown a pixel into each other and each replacing what it covers, so
|
||||
/// neighbours meet without seams and translucent colours paint once.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn fill_path_gradient(
|
||||
&mut self,
|
||||
ctx: &mut RenderContext,
|
||||
f: &Frame,
|
||||
bp: &BezPath,
|
||||
rule: FillRule,
|
||||
st: &StrokeLayer,
|
||||
chars: Option<(&Arc<TextGeom>, usize)>,
|
||||
pieces: &effects::stroke::StrokePieces,
|
||||
width: f64,
|
||||
g: &vectorcraft_color::Gradient,
|
||||
) {
|
||||
let level = (f.px * 0.25).log2().floor() as i32;
|
||||
let make = || -> Slices {
|
||||
let tol = 2f64.powi(level);
|
||||
// Reach a pixel past the stroke, so its antialiased edge has colour under it.
|
||||
let slices = effects::stroke::gradient_slices(bp, rule, st, tol, f.px + tol, f.px);
|
||||
Arc::new(
|
||||
slices
|
||||
.into_iter()
|
||||
.map(|s| {
|
||||
let (b, paint) = (s.shape.bounding_box(), s.paint(g));
|
||||
(s.shape, paint, b)
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
};
|
||||
let slices = match self.cur.clone().filter(|n| owns_stroke(n, st)) {
|
||||
Some(node) => {
|
||||
let key = (self.stroke_owner(Arc::as_ptr(&node) as usize), st as *const StrokeLayer as usize, level);
|
||||
match self.stroke_slices.get_mut(&key) {
|
||||
Some(e) if Arc::ptr_eq(&e.node, &node) => {
|
||||
e.stamp = self.stamp;
|
||||
e.slices.clone()
|
||||
}
|
||||
_ => {
|
||||
let slices = make();
|
||||
self.stroke_slices.insert(key, SliceEntry { node, slices: slices.clone(), stamp: self.stamp });
|
||||
slices
|
||||
}
|
||||
}
|
||||
}
|
||||
None => make(),
|
||||
};
|
||||
let line = match self.cached_stroke(f, chars, &pieces.line, st, width) {
|
||||
Some(o) => o,
|
||||
None => Arc::new(effects::stroke::line_outline(&pieces.line, st, width, f.px * 0.25)),
|
||||
};
|
||||
ctx.set_fill_rule(peniko::Fill::NonZero);
|
||||
for clip in std::iter::once(&*line).chain(pieces.heads.iter().map(|h| &h.outline)) {
|
||||
let cb = clip.bounding_box();
|
||||
if clip.elements().is_empty() || !cb.is_finite() {
|
||||
continue;
|
||||
}
|
||||
ctx.push_clip_layer(clip);
|
||||
ctx.set_blend_mode(BlendMode::new(Mix::Normal, Compose::Copy));
|
||||
for (shape, paint, b) in slices.iter() {
|
||||
if rects_overlap(*b, cb) && paint::set_paint(ctx, paint, *b, f) {
|
||||
ctx.fill_path(shape);
|
||||
}
|
||||
}
|
||||
ctx.set_blend_mode(BlendMode::default());
|
||||
ctx.pop_layer();
|
||||
}
|
||||
}
|
||||
|
||||
/// The line part of a stroke (see [`effects::stroke::line_outline`]), cached across frames: a
|
||||
/// character stroke of run `chars.1` of kept glyph geometry `chars.0` in `char_strokes`, a
|
||||
/// stroke of `self.cur` in `strokes` (under [`Self::stroke_owner`] and the stroke layer). The
|
||||
/// tolerance (vello's 0.25 device px) is bucketed to powers of two, never coarser than needed,
|
||||
/// so zooming reuses outlines until the level changes. Other strokes aren't cached: for them
|
||||
/// this returns `None`.
|
||||
fn cached_stroke(
|
||||
&mut self,
|
||||
f: &Frame,
|
||||
chars: Option<(&Arc<TextGeom>, usize)>,
|
||||
line: &BezPath,
|
||||
st: &StrokeLayer,
|
||||
width: f64,
|
||||
) -> Option<Arc<BezPath>> {
|
||||
let level = (f.px * 0.25).log2().floor() as i32;
|
||||
let expand = || Arc::new(effects::stroke::line_outline(line, st, width, 2f64.powi(level)));
|
||||
if let Some((g, run)) = chars {
|
||||
let key = (self.stroke_owner(Arc::as_ptr(g) as usize), run, width.to_bits(), level);
|
||||
if let Some((kept, outline)) = self.char_strokes.get(&key, self.stamp)
|
||||
&& Arc::ptr_eq(kept, g)
|
||||
{
|
||||
return Some(outline.clone());
|
||||
}
|
||||
let outline = expand();
|
||||
self.char_strokes.insert(key, (g.clone(), outline.clone()), lru::path_bytes(&outline), self.stamp);
|
||||
return Some(outline);
|
||||
}
|
||||
let node = self.cur.clone().filter(|n| owns_stroke(n, st))?;
|
||||
let key = (self.stroke_owner(Arc::as_ptr(&node) as usize), st as *const StrokeLayer as usize, width.to_bits(), level);
|
||||
if let Some(e) = self.strokes.get_mut(&key)
|
||||
&& Arc::ptr_eq(&e.node, &node)
|
||||
{
|
||||
e.stamp = self.stamp;
|
||||
return Some(e.outline.clone());
|
||||
}
|
||||
let outline = expand();
|
||||
self.strokes.insert(key, StrokeEntry { node, outline: outline.clone(), stamp: self.stamp });
|
||||
Some(outline)
|
||||
}
|
||||
|
||||
/// What the `strokes`, `char_strokes` and `stroke_slices` keys hold for a stroke owner at
|
||||
/// `address` (`self.cur` or kept glyph geometry): the address, or 0 while art made again in
|
||||
/// every frame is drawn ([`Self::made_again`]).
|
||||
fn stroke_owner(&self, address: usize) -> usize {
|
||||
if self.made_again { 0 } else { address }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
use super::*;
|
||||
use crate::paint;
|
||||
|
||||
impl Renderer {
|
||||
pub(super) fn draw_text(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, t: &TextObject) {
|
||||
let t = &*f.doc.inline_resolved(t);
|
||||
// Type drawn as `fx_owner` (the node `draw_arc` is drawing, or type art that `fx_arts`
|
||||
// keeps, see `draw_fx_art`) takes its glyph geometry from `texts`, as on the fast path,
|
||||
// except in frames that snap type to pixels.
|
||||
let owner = self.fx_owner.as_ref().filter(|o| std::ptr::eq(&***o, n)).cloned();
|
||||
let (g, kept) = match (f.text_snap(t), owner) {
|
||||
(None, Some(a)) => self.text_geom_of(&a, t),
|
||||
(snap, _) => (Arc::new(text_geom_snapped(t, snap)), false),
|
||||
};
|
||||
self.draw_text_geom(ctx, f, n, t, &g, kept);
|
||||
}
|
||||
|
||||
/// Draw the inline graphics of type `t` (laid out in `g`): each symbol's art through the
|
||||
/// normal node path, placed by the layout (inside the text's own transparency group, so its
|
||||
/// opacity and blend mode apply). A missing symbol draws nothing.
|
||||
fn draw_inlines(&mut self, ctx: &mut RenderContext, f: &Frame, t: &TextObject, g: &TextGeom) {
|
||||
if g.inlines.is_empty() && !t.runs.iter().any(|r| r.inline.is_some()) {
|
||||
return;
|
||||
}
|
||||
if self.inline_depth >= MAX_INLINE_DEPTH {
|
||||
return;
|
||||
}
|
||||
for r in t.runs.iter().filter_map(|r| r.inline.as_ref()) {
|
||||
if !f.doc.symbols.iter().any(|s| s.name == r.symbol) && !MISSING_INLINE_LOGGED.swap(true, std::sync::atomic::Ordering::Relaxed) {
|
||||
log::warn!("inline graphic shows symbol {:?}, which the document doesn't have: it draws nothing", r.symbol);
|
||||
}
|
||||
}
|
||||
self.inline_depth += 1;
|
||||
for ig in &g.inlines {
|
||||
let Some(art) = t.runs.get(ig.run).and_then(|r| r.inline.as_ref()) else { continue };
|
||||
let Some(sym) = f.doc.symbols.iter().find(|s| s.name == art.symbol) else { continue };
|
||||
// Strokes scale with the art (it is sized to the type, as in the SVG `<use>`).
|
||||
let (node, kept) = self.placed_art(&sym.art, t.xf * ig.xf * f.doc.symbol_natural_xf(&art.symbol), true, None);
|
||||
self.draw_placed_art(ctx, f, &node, kept);
|
||||
}
|
||||
self.inline_depth -= 1;
|
||||
}
|
||||
|
||||
/// Symbol art `art` as an instance or an inline graphic draws it ([`place`]), and whether it is
|
||||
/// kept. Art that is a group, a layer or a live object without an appearance of its own is kept
|
||||
/// between frames under the art's `Arc`, `xf`, `scale_strokes` and the stain of instance
|
||||
/// `inst`: it and its members keep their `Arc`s from frame to frame, and the caches keyed by a
|
||||
/// node's address (geometry, stroke outlines, glyphs, live-effect geometry, evaluated live
|
||||
/// objects) hit for them. Other art is placed again in every frame, and so is art that holds
|
||||
/// symbol instances, type with inline graphics, images, placed documents or raster effects
|
||||
/// ([`depends_on_document`]), and art that the cache has no room for. Art that holds type is
|
||||
/// placed again when the fonts change.
|
||||
pub(super) fn placed_art(&mut self, art: &Arc<Node>, xf: Affine, scale_strokes: bool, inst: Option<&Node>) -> (Arc<Node>, bool) {
|
||||
let kept_kind = matches!(art.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) || vectorcraft_doc::live::is_live(art);
|
||||
if !kept_kind || fx::has_object_fx(art) {
|
||||
return (place(art, xf, scale_strokes, inst), false);
|
||||
}
|
||||
let stain = stain_bits(inst.and_then(vectorcraft_brush::stain));
|
||||
let key = (Arc::as_ptr(art) as usize, xf.as_coeffs().map(f64::to_bits), scale_strokes, stain);
|
||||
if let Some(e) = self.placed_arts.get(&key, self.stamp)
|
||||
&& std::ptr::eq(e.art.as_ptr(), Arc::as_ptr(art))
|
||||
&& e.fonts.is_none_or(|g| g == vectorcraft_text::FontDb::global().generation())
|
||||
{
|
||||
return match &e.placed {
|
||||
Some(placed) => (placed.clone(), true),
|
||||
None => (place(art, xf, scale_strokes, inst), false),
|
||||
};
|
||||
}
|
||||
let placed = place(art, xf, scale_strokes, inst);
|
||||
let kept = (!depends_on_document(art)).then(|| placed.clone());
|
||||
let keeps = kept.is_some();
|
||||
let fonts = (keeps && holds_type(art)).then(|| vectorcraft_text::FontDb::global().generation());
|
||||
// The bytes count the key and the entry, the art's allocation that the weak reference
|
||||
// keeps, and the kept art.
|
||||
let bytes = size_of::<(PlacedKey, PlacedEntry, Node)>() + kept.as_deref().map_or(0, lru::node_bytes);
|
||||
let inserted = self.placed_arts.insert(key, PlacedEntry { art: Arc::downgrade(art), placed: kept, fonts }, bytes, self.stamp);
|
||||
(placed, keeps && inserted)
|
||||
}
|
||||
|
||||
/// Cached glyph geometry for a text node (keyed by Arc identity like paths).
|
||||
/// Text `t` that is not the node's own, such as the copy whose inline graphics
|
||||
/// `Document::inline_resolved` sized again, is laid out without the cache. Also returns
|
||||
/// whether the geometry is kept in the cache.
|
||||
pub(super) fn text_geom_of(&mut self, a: &Arc<Node>, t: &TextObject) -> (Arc<TextGeom>, bool) {
|
||||
if !matches!(&a.kind, NodeKind::Text(own) if std::ptr::eq(&**own, t)) {
|
||||
return (Arc::new(text_geom(t)), false);
|
||||
}
|
||||
let fonts = vectorcraft_text::FontDb::global().generation();
|
||||
if fonts != self.text_fonts {
|
||||
self.texts.clear();
|
||||
self.char_strokes.clear();
|
||||
self.text_fonts = fonts;
|
||||
}
|
||||
let key = Arc::as_ptr(a) as usize;
|
||||
if let Some((node, g)) = self.texts.get(&key, self.stamp)
|
||||
&& Arc::ptr_eq(node, a)
|
||||
{
|
||||
return (g.clone(), true);
|
||||
}
|
||||
let g = Arc::new(text_geom(t));
|
||||
let kept = self.texts.insert(key, (a.clone(), g.clone()), g.bytes(), self.stamp);
|
||||
(g, kept)
|
||||
}
|
||||
|
||||
/// Draw type `n` (`t`, laid out in `g`). The outlines of its character strokes are cached
|
||||
/// when `g` is kept in `texts` (`kept`).
|
||||
pub(super) fn draw_text_geom(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, t: &TextObject, g: &Arc<TextGeom>, kept: bool) {
|
||||
let xf = f.view * t.xf;
|
||||
if f.opts.outline {
|
||||
let mut p = g.all.clone();
|
||||
p.apply_affine(xf);
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
ctx.set_stroke(kurbo::Stroke::new(self.hairline));
|
||||
ctx.set_paint(peniko::Color::BLACK);
|
||||
ctx.stroke_path(&p);
|
||||
// Colour bitmap glyphs: their boxes, as images show in outline mode.
|
||||
for (_, image, to_text) in &g.images {
|
||||
let mut b = image.rect().to_path(0.1);
|
||||
b.apply_affine(t.xf * *to_text);
|
||||
self.hairline(ctx, f, &b, [0, 0, 0, 255]);
|
||||
}
|
||||
// COLR glyphs: their layers' outlines.
|
||||
for (_, art) in &g.colours {
|
||||
self.draw_colour_glyph(ctx, f, art, t.xf);
|
||||
}
|
||||
self.draw_inlines(ctx, f, t, g);
|
||||
return;
|
||||
}
|
||||
let tb = t.xf.transform_rect_bbox(g.bounds);
|
||||
// Overprinting characters darken per draw, like overprinting fills and strokes
|
||||
// ([`proof`]); the object blend mode is Normal here or applied by an enclosing layer.
|
||||
let overprints = proof::overprints(f.opts);
|
||||
let overprint = |ctx: &mut RenderContext, on: bool| {
|
||||
if overprints {
|
||||
ctx.set_blend_mode(if on { blend_mode(vectorcraft_color::BlendMode::Darken) } else { BlendMode::default() });
|
||||
}
|
||||
};
|
||||
// The object's own fills and strokes paint the whole outline: those below the Characters
|
||||
// row under the characters' own fill and stroke, the others over them.
|
||||
let (below, above) = n.appearance.split_contents();
|
||||
let all = (!n.appearance.items.is_empty()).then(|| {
|
||||
let mut all = g.all.clone();
|
||||
all.apply_affine(t.xf);
|
||||
all
|
||||
});
|
||||
if let Some(all) = &all {
|
||||
self.draw_text_items(ctx, f, n, below, all, tb);
|
||||
}
|
||||
if f.opts.highlight_substitutions {
|
||||
for (on, path) in [
|
||||
(f.opts.highlight_substituted_fonts, Some(&g.substituted_fonts)),
|
||||
(f.doc.setup.highlight_substituted_glyphs, Some(&g.substituted_glyphs)),
|
||||
// Measured only when shown: it lays the text out again.
|
||||
(f.opts.highlight_alternate_glyphs, f.opts.highlight_alternate_glyphs.then(|| g.alternate_glyphs(t))),
|
||||
] {
|
||||
let Some(path) = path else { continue };
|
||||
if on && !path.elements().is_empty() {
|
||||
ctx.set_transform(xf);
|
||||
ctx.set_fill_rule(peniko::Fill::NonZero);
|
||||
ctx.set_paint(SUBSTITUTED);
|
||||
ctx.fill_path(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i, run) in t.runs.iter().enumerate() {
|
||||
// Colour bitmap glyphs paint themselves: the run's fill and stroke don't.
|
||||
for (_, image, to_text) in g.images.iter().filter(|(r, ..)| *r == i) {
|
||||
overprint(ctx, false);
|
||||
self.draw_glyph_image(ctx, f, image, t.xf * *to_text);
|
||||
}
|
||||
for (_, art) in g.colours.iter().filter(|(r, _)| *r == i) {
|
||||
self.draw_colour_glyph(ctx, f, art, t.xf);
|
||||
}
|
||||
let path = g.run(i);
|
||||
let path = path.as_ref();
|
||||
if path.elements().is_empty() {
|
||||
continue;
|
||||
}
|
||||
ctx.set_transform(xf);
|
||||
ctx.set_fill_rule(peniko::Fill::NonZero);
|
||||
if paint::set_fill_paint(ctx, &run.style.fill, g.bounds, f) {
|
||||
self.fold_alpha(ctx, f.ink, &run.style.fill);
|
||||
overprint(ctx, run.style.overprint_fill);
|
||||
ctx.fill_path(path);
|
||||
}
|
||||
if run.style.has_stroke() {
|
||||
// Character strokes are drawn in text space, with their cap, join and dashes.
|
||||
overprint(ctx, run.style.overprint_stroke);
|
||||
let chars = kept.then_some((g, i));
|
||||
self.draw_stroke(ctx, f, t.xf, path, FillRule::NonZero, &run.style.stroke_layer(), chars, g.bounds);
|
||||
}
|
||||
}
|
||||
overprint(ctx, false);
|
||||
self.draw_inlines(ctx, f, t, g);
|
||||
if let Some(all) = &all {
|
||||
self.draw_text_items(ctx, f, n, above, all, tb);
|
||||
}
|
||||
}
|
||||
|
||||
/// Paint some of type `n`'s own fills and strokes (`items`) on its glyph outlines `all`
|
||||
/// (document space; `tb` their bounds). Fills composite with their own opacity and blend mode;
|
||||
/// strokes take every stroke option, as on paths.
|
||||
fn draw_text_items(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, items: &[AppearanceItem], all: &BezPath, tb: Rect) {
|
||||
for item in items.iter().filter(|i| i.visible() && !i.paint().is_none()) {
|
||||
match item {
|
||||
AppearanceItem::Fill(fl) => {
|
||||
let layered = fl.opacity < 1.0 || fl.blend != vectorcraft_color::BlendMode::Normal;
|
||||
if layered {
|
||||
ctx.set_transform(Affine::IDENTITY);
|
||||
ctx.push_layer(None, Some(blend_mode(fl.blend)), Some(fl.opacity), None, None);
|
||||
}
|
||||
ctx.set_transform(f.view);
|
||||
if paint::set_fill_paint(ctx, &fl.paint, tb, f) {
|
||||
ctx.set_fill_rule(peniko::Fill::NonZero);
|
||||
ctx.fill_path(all);
|
||||
}
|
||||
if layered {
|
||||
ctx.pop_layer();
|
||||
}
|
||||
}
|
||||
AppearanceItem::Stroke(st) if st.width > 0.0 => {
|
||||
if st.brush.is_none() || !self.draw_brush(ctx, f, n, all, st) {
|
||||
self.draw_stroke(ctx, f, Affine::IDENTITY, all, FillRule::NonZero, st, None, tb);
|
||||
}
|
||||
}
|
||||
AppearanceItem::Stroke(_) => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Draw COLR glyph `art` (its layers in text space) through `xf` (text space → document), as
|
||||
/// art: kept between frames as symbol art is ([`Self::placed_art`]).
|
||||
fn draw_colour_glyph(&mut self, ctx: &mut RenderContext, f: &Frame, art: &Arc<Node>, xf: Affine) {
|
||||
let (node, kept) = self.placed_art(art, xf, true, None);
|
||||
let outer = std::mem::replace(&mut self.made_again, !kept);
|
||||
self.draw_node(ctx, f, &node, true);
|
||||
self.made_again = outer;
|
||||
}
|
||||
|
||||
/// Draw colour bitmap glyph `image` through `xf` (its pixels → document space), its pixels
|
||||
/// decoded once and kept with the images' pixels.
|
||||
fn draw_glyph_image(&mut self, ctx: &mut RenderContext, f: &Frame, image: &vectorcraft_text::GlyphImage, xf: Affine) {
|
||||
let Some((key, pm)) = blob_pixmap(&image.blob, true) else { return };
|
||||
let (key, pm) = ink::ink_image(&key, &pm, f.ink, Some(&image.blob), true);
|
||||
let unit = f.view * xf * Affine::scale_non_uniform(image.width as f64, image.height as f64);
|
||||
let pm = image_mip(&key, pm, unit);
|
||||
let sx = image.width as f64 / pm.width().max(1) as f64;
|
||||
let sy = image.height as f64 / pm.height().max(1) as f64;
|
||||
let quality = if f.opts.smooth_images { peniko::ImageQuality::Medium } else { peniko::ImageQuality::Low };
|
||||
ctx.set_paint(vello_cpu::Image {
|
||||
image: vello_cpu::ImageSource::Pixmap(pm),
|
||||
sampler: peniko::ImageSampler { quality, ..Default::default() },
|
||||
});
|
||||
ctx.set_transform(f.view * xf);
|
||||
ctx.set_paint_transform(Affine::scale_non_uniform(sx, sy));
|
||||
ctx.fill_rect(&image.rect());
|
||||
ctx.reset_paint_transform();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user