b45255bb6fe2
draw.rs
//! The scene walk: nodes → krilla surface operations, in page space.
use std::collections::HashMap;
use figcraft_color::{BlendMode, Gradient, GradientKind, ImagePaint, ImageScaleMode, Paint, PaintKind, PatternPaint};
use figcraft_doc::{Document, EffectKind, MaskType as DocMaskType, Node, NodeId, NodeKind, StrokeAlign};
use figcraft_geom::{Affine, BezPath, Rect, Shape};
use crate::raster::Raster;
use krilla::geom::{Path, PathBuilder, Size, Transform};
use krilla::image::Image;
use krilla::mask::{Mask, MaskType};
use krilla::num::NormalizedF32;
use krilla::paint::{Fill, FillRule, LinearGradient, Pattern, RadialGradient, SpreadMethod, Stop};
use krilla::surface::Surface;
use crate::PdfOptions;
use crate::print::Ink;
/// Deepest node nesting drawn (the renderer's limit).
pub(crate) const MAX_DEPTH: usize = figcraft_render::MAX_EXPORT_DEPTH;
/// Largest side of any raster made for the PDF, in pixels.
pub(crate) const MAX_RASTER_SIDE: f64 = 4096.0;
#[derive(Clone, Copy)]
pub(crate) struct PaintSize {
pub width: f64,
pub height: f64,
}
#[derive(Clone, Copy)]
pub(crate) struct PaintFrame {
pub size: PaintSize,
pub transform: Affine,
}
pub(crate) struct Exporter<'a> {
pub doc: &'a Document,
pub opts: &'a PdfOptions,
/// Page coordinates → PDF page coordinates for the page being drawn.
pub page_origin: Affine,
/// The page's area in document page coordinates.
pub page_rect: Rect,
/// The layers drawn on the current page (z-order): what background blurs see behind them.
pub page_ids: Vec<NodeId>,
/// Text hyperlinks on the current page: their areas (PDF page coordinates) and URLs.
pub links: Vec<(Rect, String)>,
/// Above zero while drawing into a soft mask (nothing there is visible or clickable).
pub(crate) masking: usize,
/// Above zero while drawing a pattern tile (links and backdrops belong to the page).
pub(crate) tiling: usize,
/// The page's frame and the bleed its fills and clip reach out to.
pub bleed_root: Option<(NodeId, f64)>,
pub(crate) fonts: HashMap<u32, Option<krilla::text::Font>>,
images: HashMap<String, Option<(Image, u32, u32)>>,
}
pub(crate) fn to_xf(a: Affine) -> Transform {
let c = a.as_coeffs();
Transform::from_row(c[0] as f32, c[1] as f32, c[2] as f32, c[3] as f32, c[4] as f32, c[5] as f32)
}
/// Finite and in a range f32 PDF numbers can hold.
pub(crate) fn affine_ok(a: Affine) -> bool {
a.as_coeffs().iter().all(|v| v.is_finite() && v.abs() < 1e9)
}
/// kurbo path → krilla path (`None` when empty, degenerate or not finite).
pub(crate) fn to_path(p: &BezPath) -> Option<Path> {
use figcraft_geom::kurbo::PathEl;
if p.elements().is_empty() || !figcraft_pathops::finite(p) {
return None;
}
let mut b = PathBuilder::new();
for el in p.elements() {
match *el {
PathEl::MoveTo(a) => b.move_to(a.x as f32, a.y as f32),
PathEl::LineTo(a) => b.line_to(a.x as f32, a.y as f32),
PathEl::QuadTo(c, a) => b.quad_to(c.x as f32, c.y as f32, a.x as f32, a.y as f32),
PathEl::CurveTo(c1, c2, a) => b.cubic_to(c1.x as f32, c1.y as f32, c2.x as f32, c2.y as f32, a.x as f32, a.y as f32),
PathEl::ClosePath => b.close(),
}
}
b.finish()
}
/// `v > min`, false for NaN.
pub(crate) fn above<T: PartialOrd>(v: T, min: T) -> bool {
v > min
}
pub(crate) fn norm(v: f32) -> NormalizedF32 {
let v = if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 };
NormalizedF32::new(v).unwrap_or(NormalizedF32::ONE)
}
/// The PDF blend mode for a non-normal blend (`None` = normal / pass through).
pub(crate) fn blend(b: BlendMode) -> Option<krilla::blend::BlendMode> {
use krilla::blend::BlendMode as K;
Some(match b {
BlendMode::PassThrough | BlendMode::Normal => return None,
BlendMode::Darken => K::Darken,
BlendMode::Multiply => K::Multiply,
// PDF has no plus-darker/plus-lighter: the nearest separable modes.
BlendMode::PlusDarker => K::Multiply,
BlendMode::ColorBurn => K::ColorBurn,
BlendMode::Lighten => K::Lighten,
BlendMode::Screen => K::Screen,
BlendMode::PlusLighter => K::Screen,
BlendMode::ColorDodge => K::ColorDodge,
BlendMode::Overlay => K::Overlay,
BlendMode::SoftLight => K::SoftLight,
BlendMode::HardLight => K::HardLight,
BlendMode::Difference => K::Difference,
BlendMode::Exclusion => K::Exclusion,
BlendMode::Hue => K::Hue,
BlendMode::Saturation => K::Saturation,
BlendMode::Color => K::Color,
BlendMode::Luminosity => K::Luminosity,
})
}
pub(crate) fn rule(r: figcraft_render::FillRule) -> FillRule {
match r {
figcraft_render::FillRule::EvenOdd => FillRule::EvenOdd,
figcraft_render::FillRule::Winding => FillRule::NonZero,
}
}
/// The renderer's stroke fill rule: even-odd ring paths for aligned strokes, else non-zero.
pub(crate) fn stroke_rule(n: &Node, closed: bool) -> FillRule {
if n.stroke.sides.is_some() || (n.stroke.dashes.is_empty() && closed && n.stroke.align != StrokeAlign::Center) {
FillRule::EvenOdd
} else {
FillRule::NonZero
}
}
/// The gradient's unit frame in a w×h box: (0,0)→from, (1,0)→to, (0,1)→width handle.
fn handle_frame(g: &Gradient, w: f64, h: f64) -> Affine {
let f = (g.from.0 * w, g.from.1 * h);
let t = (g.to.0 * w, g.to.1 * h);
let k = (g.width.0 * w, g.width.1 * h);
Affine::new([t.0 - f.0, t.1 - f.1, k.0 - f.0, k.1 - f.1, f.0, f.1])
}
/// A paint PDF can express directly (solid, linear, radial) on a w×h box, in `ink`, with its fill
/// opacity.
pub(crate) fn vector_paint(p: &Paint, w: f64, h: f64, ink: Ink) -> Option<(krilla::paint::Paint, NormalizedF32)> {
if !p.visible || !above(p.opacity, 0.0) {
return None;
}
let op = p.opacity.clamp(0.0, 1.0);
match &p.kind {
PaintKind::Solid { color } => {
let a = color.a * op;
(a > 0.0).then(|| (ink.color(*color).into(), norm(a)))
}
PaintKind::Gradient(g) if matches!(g.kind, GradientKind::Linear | GradientKind::Radial) => {
let frame = handle_frame(g, w.max(1e-6), h.max(1e-6));
if !affine_ok(frame) || !above(frame.determinant().abs(), 1e-12) {
return None;
}
let mut stops: Vec<Stop> = g
.sorted_stops()
.into_iter()
.map(|s| Stop { offset: norm(s.position), color: ink.color(s.color), opacity: norm(s.color.a * op) })
.collect();
if stops.len() == 1
&& let Some(only) = stops.first().cloned()
{
stops = vec![Stop { offset: norm(0.0), ..only.clone() }, Stop { offset: norm(1.0), ..only }];
}
let transform = to_xf(frame);
let paint: krilla::paint::Paint = match g.kind {
GradientKind::Linear => {
LinearGradient { x1: 0.0, y1: 0.0, x2: 1.0, y2: 0.0, transform, spread_method: SpreadMethod::Pad, stops, anti_alias: false }
.into()
}
_ => RadialGradient {
fx: 0.0,
fy: 0.0,
fr: 0.0,
cx: 0.0,
cy: 0.0,
cr: 1.0,
transform,
spread_method: SpreadMethod::Pad,
stops,
anti_alias: false,
}
.into(),
};
Some((paint, NormalizedF32::ONE))
}
_ => None,
}
}
enum Sniffed {
Png,
Jpeg,
Gif,
Webp,
Other,
}
fn sniff(b: &[u8]) -> Sniffed {
if b.starts_with(&[0x89, b'P', b'N', b'G']) {
Sniffed::Png
} else if b.starts_with(&[0xFF, 0xD8]) {
Sniffed::Jpeg
} else if b.starts_with(b"GIF") {
Sniffed::Gif
} else if b.len() > 12 && b.get(8..12) == Some(b"WEBP") {
Sniffed::Webp
} else {
Sniffed::Other
}
}
impl<'a> Exporter<'a> {
pub(crate) fn new(doc: &'a Document, opts: &'a PdfOptions) -> Self {
Self {
doc,
opts,
page_origin: Affine::IDENTITY,
page_rect: Rect::ZERO,
page_ids: Vec::new(),
links: Vec::new(),
masking: 0,
tiling: 0,
bleed_root: None,
fonts: HashMap::new(),
images: HashMap::new(),
}
}
/// The colour model of what's drawn now: CMYK when printing in it, but never in soft masks
/// (they aren't printed).
pub(crate) fn ink(&self) -> Ink {
if self.opts.print.cmyk && self.masking == 0 { Ink::Cmyk } else { Ink::Rgb }
}
/// Draw node `id`; `parent_xf` maps its parent's space to PDF page space. `as_mask` draws a
/// mask layer itself (into a soft mask).
pub(crate) fn node(&mut self, s: &mut Surface, id: NodeId, parent_xf: Affine, depth: usize, as_mask: bool) {
// What the renderer draws for this layer (images of its effects, pattern cells) and its
// pattern sources go on from its depth: one cap for the whole export (#1082).
figcraft_render::at_layer_depth(depth, || self.layer(s, id, parent_xf, depth, as_mask));
}
fn layer(&mut self, s: &mut Surface, id: NodeId, parent_xf: Affine, depth: usize, as_mask: bool) {
if depth > MAX_DEPTH {
return;
}
let doc = self.doc;
let Some(n) = doc.node(id) else { return };
if !n.visible || !above(n.opacity, 0.0) || (n.is_mask && !as_mask) {
return;
}
let xf = parent_xf * n.transform;
if !affine_ok(xf) {
return;
}
let fx: Vec<&EffectKind> = n.effects.iter().filter(|e| e.visible).map(|e| &e.kind).collect();
let op = n.opacity.clamp(0.0, 1.0);
// Background blur and glass: an image drawn from what lies under the node, under its
// content (nothing in a soft mask is seen).
let back =
if !as_mask && self.masking == 0 && self.tiling == 0 && figcraft_render::backdrop::has_effects(n) { self.backdrop(id) } else { None };
if fx.iter().any(|k| matches!(k, EffectKind::LayerBlur { .. } | EffectKind::Noise(_) | EffectKind::Texture(_))) {
// Effects that change every pixel: the renderer draws the whole node.
if let Some(b) = &back {
self.place_raster(s, b, op, n.blend);
}
self.raster_node(s, id);
return;
}
let shadows = if fx.iter().any(|k| matches!(k, EffectKind::DropShadow(_) | EffectKind::InnerShadow(_))) { self.shadows(id) } else { None };
// Drop shadows go under the node, with its opacity.
if let Some(sh) = &shadows {
for (r, b) in &sh.drop {
self.place_raster(s, r, op, *b);
}
}
let nb = blend(n.blend);
if let Some(b) = nb {
s.push_blend_mode(b);
}
// A blending layer, or a group set to Normal, composites its content in a group of its own.
let isolated = nb.is_some() || n.isolates_children();
if isolated {
s.push_isolated();
}
if op < 1.0 {
s.push_opacity(norm(op));
}
if let Some(b) = &back {
self.place_raster(s, b, 1.0, BlendMode::Normal);
}
self.content(s, n, xf, depth, shadows.as_ref().map_or(&[], |sh| sh.inner.as_slice()));
if op < 1.0 {
s.pop();
}
if isolated {
s.pop();
}
if nb.is_some() {
s.pop();
}
}
/// Fills, `inner` shadows (over the fills, under the children and strokes), children
/// (clipped), strokes and text of a node, without opacity/effects.
fn content(&mut self, s: &mut Surface, n: &Node, xf: Affine, depth: usize, inner: &[Raster]) {
let (w, h) = (n.width, n.height);
match &n.kind {
NodeKind::Page { .. } | NodeKind::Group => {
self.children(s, n, xf, depth);
// A group's inner shadows lie over its layers.
self.place_inner(s, inner);
}
NodeKind::Text(_) => crate::text::draw_text(self, s, n, xf, inner),
_ => {
// The page's frame reaches out to the bleed (fills and clip; paints keep their box).
let outline = match self.bleed_root {
Some((id, b)) if id == n.id && n.kind.is_frame_like() => {
Some((Rect::new(-b, -b, w + b, h + b).to_path(0.1), figcraft_render::FillRule::Winding))
}
_ => figcraft_render::node_outline(self.doc, n),
};
let is_bool = matches!(n.kind, NodeKind::BooleanOp { .. });
let closed = figcraft_doc::geometry::is_closed(n) || is_bool;
if let Some((path, r)) = &outline
&& closed
{
if let NodeKind::Vector { network } = &n.kind
&& network.regions.iter().any(|r| r.fills.is_some() || r.paint_space.is_some())
{
let drawn = figcraft_doc::geometry::drawn_network(network, n.corners.smoothing);
let net = drawn.as_ref();
for (i, region) in net.regions.iter().enumerate() {
let paints = region.fills.as_deref().unwrap_or(&n.fills);
if let Some(mut region_path) = net.region_path(i) {
let (pw, ph, frame) = region.paint_frame(w, h);
region_path.apply_affine(frame.inverse());
let fill_rule =
if region.winding == figcraft_doc::WindingRule::EvenOdd { FillRule::EvenOdd } else { FillRule::NonZero };
for p in paints {
self.fill(
s,
®ion_path,
fill_rule,
p,
PaintFrame { size: PaintSize { width: pw, height: ph }, transform: xf * frame },
);
}
}
}
} else {
for p in &n.fills {
self.fill(s, path, rule(*r), p, PaintFrame { size: PaintSize { width: w, height: h }, transform: xf });
}
}
}
self.place_inner(s, inner);
if !is_bool && !n.children.is_empty() {
if n.clip && n.kind.is_frame_like() {
// Clip content: children outside the frame's outline are cut off (and
// nothing shows through a degenerate frame, like the renderer).
let clip = outline.as_ref().and_then(|(p, _)| {
let mut cp = p.clone();
cp.apply_affine(xf);
to_path(&cp)
});
if let Some(cp) = clip {
s.push_clip_path(&cp, &FillRule::NonZero);
self.children(s, n, xf, depth);
s.pop();
}
} else {
self.children(s, n, xf, depth);
}
}
if n.has_visible_stroke() {
let geom = if is_bool { outline.as_ref().map(|(p, _)| p.clone()) } else { figcraft_doc::geometry::stroke_geometry(n) };
if let Some(g) = geom {
let area = figcraft_render::draw::stroke_area(n, &g, closed);
for p in &n.strokes {
self.fill(s, &area, stroke_rule(n, closed), p, PaintFrame { size: PaintSize { width: w, height: h }, transform: xf });
}
}
}
}
}
}
fn children(&mut self, s: &mut Surface, n: &Node, xf: Affine, depth: usize) {
let doc = self.doc;
let kids = &n.children;
for run in doc.paint_runs(n) {
let Some(&c) = kids.get(run.start) else { continue };
if doc.node(c).is_some_and(|cn| cn.is_mask && cn.visible) {
// Everything above the mask (until the next mask) shows through its alpha.
self.masked(s, c, kids.get(run.start + 1..run.end).unwrap_or(&[]), xf, depth);
} else {
self.node(s, c, xf, depth + 1, false);
}
}
}
/// `content` drawn through mask layer `mask_id`: its alpha or luminance (a soft mask drawn from
/// the mask layer, so vector, gradient and image masks all work), or its outline (a clip path).
fn masked(&mut self, s: &mut Surface, mask_id: NodeId, content: &[NodeId], xf: Affine, depth: usize) {
let Some(m) = self.doc.node(mask_id).filter(|_| !content.is_empty()) else { return };
let kind = match m.mask_type {
DocMaskType::Vector => {
// The outline, fully opaque; nothing shows through a mask without one.
let mut plain = m.clone();
plain.is_mask = false;
let clip = figcraft_render::subtree_outline(self.doc, &plain, depth + 1).and_then(|(mut p, r)| {
p.apply_affine(xf * m.transform);
Some((to_path(&p)?, rule(r)))
});
if let Some((cp, r)) = clip {
s.push_clip_path(&cp, &r);
self.draw_all(s, content, xf, depth);
s.pop();
}
return;
}
DocMaskType::Luminance => MaskType::Luminosity,
DocMaskType::Alpha => MaskType::Alpha,
};
let stream = {
let mut sb = s.stream_builder();
let mut ms = sb.surface();
self.masking += 1;
self.node(&mut ms, mask_id, xf, depth + 1, true);
self.masking -= 1;
ms.finish();
sb.finish()
};
s.push_mask(Mask::new(stream, kind));
self.draw_all(s, content, xf, depth);
s.pop();
}
fn draw_all(&mut self, s: &mut Surface, ids: &[NodeId], xf: Affine, depth: usize) {
for c in ids {
self.node(s, *c, xf, depth + 1, false);
}
}
/// Fill `path` (local space, mapped to the page by `xf`) with one paint on a w×h box.
pub(crate) fn fill(&mut self, s: &mut Surface, path: &BezPath, r: FillRule, p: &Paint, frame: PaintFrame) {
let PaintFrame { size: PaintSize { width: w, height: h }, transform: xf } = frame;
if !p.visible || !above(p.opacity, 0.0) {
return;
}
let Some(kp) = to_path(path) else { return };
let pb = blend(p.blend);
if let Some(b) = pb {
s.push_blend_mode(b);
}
s.push_transform(&to_xf(xf));
match &p.kind {
PaintKind::Image(img) => self.image_fill(s, &kp, r, img, p.opacity.clamp(0.0, 1.0), frame.size),
PaintKind::Pattern(pt) => {
if !self.pattern_fill(s, &kp, r, pt, p.opacity.clamp(0.0, 1.0), frame.size) {
self.raster_paint(s, path, &kp, r, p, frame);
}
}
PaintKind::Gradient(g) if !matches!(g.kind, GradientKind::Linear | GradientKind::Radial) => self.raster_paint(s, path, &kp, r, p, frame),
_ => {
if let Some((paint, opacity)) = vector_paint(p, w, h, self.ink()) {
s.set_fill(Some(Fill { paint, opacity, rule: r }));
s.draw_path(&kp);
}
}
}
s.pop();
if pb.is_some() {
s.pop();
}
}
/// The PDF image for an image paint and its pixel size (cached per image + adjustments).
fn image(&mut self, img: &ImagePaint) -> Option<(Image, u32, u32)> {
let ink = self.ink();
let key = format!("{}|{:?}|{ink:?}", img.image, img.filters);
if let Some(i) = self.images.get(&key) {
return i.clone();
}
let data = self.doc.images.get(&img.image);
// Decoding through the renderer checks the image is readable and applies adjustments.
let made = figcraft_render::images::get(&img.image, data, &img.filters, self.doc.color_profile).map(|pm| {
let (pw, ph) = (pm.width(), pm.height());
// Unadjusted RGB images embed their original bytes (JPEG stays JPEG).
let original = data.filter(|_| img.filters.is_identity() && ink == Ink::Rgb).and_then(|d| {
let bytes = krilla::Data::from(d.bytes.clone());
match sniff(&d.bytes) {
Sniffed::Png => Image::from_png(bytes, true).ok(),
Sniffed::Jpeg => Image::from_jpeg(bytes, true).ok(),
Sniffed::Gif => Image::from_gif(bytes, true).ok(),
Sniffed::Webp => Image::from_webp(bytes, true).ok(),
Sniffed::Other => None,
}
});
let image = original.filter(|i| i.size() == (pw, ph)).unwrap_or_else(|| ink.bitmap(figcraft_render::to_rgba8(&pm), pw, ph));
(image, pw, ph)
});
self.images.insert(key, made.clone());
made
}
/// An image fill; the surface is in the node's local space.
fn image_fill(&mut self, s: &mut Surface, kp: &Path, r: FillRule, img: &ImagePaint, op: f32, size: PaintSize) {
let PaintSize { width: w, height: h } = size;
let Some((image, iw, ih)) = self.image(img) else { return };
let t = figcraft_render::paint::image_transform(img, f64::from(iw), f64::from(ih), w, h);
let t = Affine::new([f64::from(t.sx), f64::from(t.ky), f64::from(t.kx), f64::from(t.sy), f64::from(t.tx), f64::from(t.ty)]);
let Some(size) = Size::from_wh(iw as f32, ih as f32) else { return };
if !affine_ok(t) || !above(t.determinant().abs(), 1e-12) {
return;
}
if op < 1.0 {
s.push_opacity(norm(op));
}
if img.scale_mode == ImageScaleMode::Tile {
let stream = {
let mut sb = s.stream_builder();
let mut ps = sb.surface();
ps.draw_image(image, size);
ps.finish();
sb.finish()
};
let pattern = Pattern { stream, transform: to_xf(t), width: iw as f32, height: ih as f32 };
s.set_fill(Some(Fill { paint: pattern.into(), opacity: NormalizedF32::ONE, rule: r }));
s.draw_path(kp);
} else {
s.push_clip_path(kp, &r);
s.push_transform(&to_xf(t));
s.draw_image(image, size);
s.pop();
s.pop();
}
if op < 1.0 {
s.pop();
}
}
/// A pattern fill as a PDF tiling pattern of the source's vectors; false (draw it as an image
/// instead) when the source has effects, which the PDF draws as page-placed images.
fn pattern_fill(&mut self, s: &mut Surface, kp: &Path, r: FillRule, pt: &PatternPaint, op: f32, size: PaintSize) -> bool {
let PaintSize { width: w, height: h } = size;
let doc = self.doc;
let Some(src) = doc.node(NodeId(pt.source)).filter(|n| !n.is_page()) else { return true };
if doc.subtree(src.id).iter().filter_map(|i| doc.node(*i)).any(|n| n.effects.iter().any(|e| e.visible)) {
return false;
}
let Some(cell) = pt.cell(src.width, src.height, w, h) else { return true };
let unrotated = src.transform.inverse();
let stream = {
let mut sb = s.stream_builder();
let mut ps = sb.surface();
// Links and backdrops belong to the page, not to a tile.
self.tiling += 1;
// The source is one level below the layer it fills.
let depth = figcraft_render::layer_depth() + 1;
let _ = figcraft_render::pattern::nested(|| {
for (tx, ty) in &cell.tiles {
self.node(&mut ps, src.id, Affine::translate((*tx, *ty)) * Affine::scale(cell.scale) * unrotated, depth, false);
}
Some(())
});
self.tiling -= 1;
ps.finish();
sb.finish()
};
if op < 1.0 {
s.push_opacity(norm(op));
}
let pattern = Pattern { stream, transform: to_xf(Affine::translate(cell.origin)), width: cell.size.0 as f32, height: cell.size.1 as f32 };
s.set_fill(Some(Fill { paint: pattern.into(), opacity: NormalizedF32::ONE, rule: r }));
s.draw_path(kp);
if op < 1.0 {
s.pop();
}
true
}
/// Angular and diamond gradients, and patterns of sources with effects: an image of the paint
/// over the path's bounds, clipped to it. The surface is in the node's local space; `xf` (local → page) sets the resolution.
fn raster_paint(&mut self, s: &mut Surface, path: &BezPath, kp: &Path, r: FillRule, p: &Paint, frame: PaintFrame) {
let PaintFrame { size: PaintSize { width: w, height: h }, transform: xf } = frame;
let bb = path.bounding_box();
if !(bb.width() > 0.0 && bb.height() > 0.0 && crate::rect_finite(bb)) {
return;
}
let page_scale = xf.determinant().abs().sqrt();
let mut k = self.raster_scale() * if page_scale.is_finite() && page_scale > 0.0 { page_scale } else { 1.0 };
let side = bb.width().max(bb.height()) * k;
if side > MAX_RASTER_SIDE {
k *= MAX_RASTER_SIDE / side;
}
let (pw, ph) = ((bb.width() * k).ceil().max(1.0) as u32, (bb.height() * k).ceil().max(1.0) as u32);
let Some(prep) = figcraft_render::paint::prepare(p, w, h, k, self.doc) else { return };
let Some(mut pix) = tiny_skia::Pixmap::new(pw, ph) else { return };
let paint = tiny_skia::Paint { shader: prep.shader(), anti_alias: false, ..Default::default() };
let Some(rect) = tiny_skia::Rect::from_xywh(bb.x0 as f32, bb.y0 as f32, bb.width() as f32, bb.height() as f32) else { return };
pix.fill_rect(rect, &paint, tiny_skia::Transform::from_row(k as f32, 0.0, 0.0, k as f32, (-bb.x0 * k) as f32, (-bb.y0 * k) as f32), None);
let Some(size) = Size::from_wh(pw as f32, ph as f32) else { return };
let image = self.ink().bitmap(figcraft_render::to_rgba8(&pix), pw, ph);
s.push_clip_path(kp, &r);
s.push_transform(&to_xf(Affine::translate((bb.x0, bb.y0)) * Affine::scale(1.0 / k)));
s.draw_image(image, size);
s.pop();
s.pop();
}
pub(crate) fn raster_scale(&self) -> f64 {
let k = self.opts.raster_scale;
if k.is_finite() { k.clamp(0.25, 8.0) } else { 2.0 }
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.