290 lines
13 KiB
Rust
290 lines
13 KiB
Rust
//! Fills: solid, gradient, picture and pattern paints.
|
|
|
|
use deckcraft_color::Rgba;
|
|
use deckcraft_geom::preset::FillMode;
|
|
use deckcraft_model::resolve::Ctx;
|
|
use deckcraft_model::style::{ColorRef, Fill, GradientShape, PictureFill, PictureMode};
|
|
use deckcraft_model::{PhType, Presentation};
|
|
use kurbo::{Affine, BezPath, Point, Rect, Shape as _};
|
|
use vello_cpu::{RenderContext, peniko};
|
|
|
|
use crate::{color, images, shade};
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn fill_path(
|
|
ctx: &mut RenderContext,
|
|
rctx: &Ctx,
|
|
fill: &Fill,
|
|
ph: Option<Rgba>,
|
|
path: &BezPath,
|
|
bounds: Rect,
|
|
m: Affine,
|
|
mode: FillMode,
|
|
alpha: f64,
|
|
pres: &Presentation,
|
|
) {
|
|
ctx.set_transform(m);
|
|
match fill {
|
|
Fill::None | Fill::Group | Fill::Background => {}
|
|
Fill::Solid { color: c } => {
|
|
let col = shade(rctx.color(c, ph), mode);
|
|
ctx.set_paint(color(col, alpha));
|
|
ctx.fill_path(path);
|
|
}
|
|
Fill::Gradient(g) => {
|
|
if g.stops.is_empty() {
|
|
return;
|
|
}
|
|
let stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos, shade(rctx.color(&s.color, ph), mode))).collect();
|
|
ctx.set_paint(gradient(&g.shape, stops, bounds, alpha));
|
|
|
|
let mut stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0), shade(rctx.color(&s.color, ph), mode))).collect();
|
|
stops.sort_by(|a, b| a.0.total_cmp(&b.0));
|
|
// Rectangle and outline paths: rasterised (see `pathgrad`).
|
|
if let GradientShape::Path { path: kind, focus } = &g.shape
|
|
&& matches!(kind.as_str(), "rect" | "shape")
|
|
{
|
|
crate::pathgrad::fill(ctx, kind, *focus, &crate::ramp::expand(&stops), bounds, path, m, alpha);
|
|
return;
|
|
}
|
|
// PowerPoint's ramp between stops (linear light, S-shaped), see `ramp`.
|
|
let stops: Vec<peniko::ColorStop> =
|
|
crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
|
|
let grad = match &g.shape {
|
|
GradientShape::Linear { angle, .. } => {
|
|
// Angle measured clockwise from left→right; span the bounds along that direction.
|
|
let a = angle.to_radians();
|
|
let (dx, dy) = (a.cos(), a.sin());
|
|
let c = bounds.center();
|
|
let half = (bounds.width() * dx.abs() + bounds.height() * dy.abs()) / 2.0;
|
|
peniko::Gradient::new_linear(Point::new(c.x - dx * half, c.y - dy * half), Point::new(c.x + dx * half, c.y + dy * half))
|
|
.with_stops(stops.as_slice())
|
|
}
|
|
GradientShape::Path { focus, .. } => {
|
|
let fx = bounds.x0 + bounds.width() * (focus[0] + (1.0 - focus[2])) / 2.0;
|
|
let fy = bounds.y0 + bounds.height() * (focus[1] + (1.0 - focus[3])) / 2.0;
|
|
// Reach the farthest corner, so a gradient from a corner covers the whole box.
|
|
let r = [(bounds.x0, bounds.y0), (bounds.x1, bounds.y0), (bounds.x0, bounds.y1), (bounds.x1, bounds.y1)]
|
|
.iter()
|
|
.map(|(x, y)| ((x - fx).powi(2) + (y - fy).powi(2)).sqrt())
|
|
.fold(1e-6, f64::max);
|
|
peniko::Gradient::new_radial(Point::new(fx, fy), r as f32).with_stops(stops.as_slice())
|
|
}
|
|
};
|
|
ctx.set_paint(grad);
|
|
ctx.fill_path(path);
|
|
}
|
|
Fill::Picture(pf) => {
|
|
ctx.push_clip_layer(path);
|
|
picture(ctx, pres, &resolved(rctx, pf, ph), bounds, m, None);
|
|
ctx.pop_layer();
|
|
}
|
|
Fill::Pattern(p) => {
|
|
let fg = rctx.color(&p.fg, ph);
|
|
let bg = rctx.color(&p.bg, ph);
|
|
crate::pattern::fill(ctx, &p.preset, fg, bg, alpha, path, m);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// `pf` with its duotone colours resolved to plain RGB against the slide's colours and the
|
|
/// placeholder colour `ph` (theme background pictures recolour with `phClr`), so the decoded-image
|
|
/// cache can apply and key them without a colour scheme.
|
|
pub fn resolved<'a>(rctx: &Ctx, pf: &'a PictureFill, ph: Option<Rgba>) -> std::borrow::Cow<'a, PictureFill> {
|
|
let Some((d, l)) = &pf.adjust.duotone else { return std::borrow::Cow::Borrowed(pf) };
|
|
let mut out = pf.clone();
|
|
out.adjust.duotone = Some((ColorRef::rgb(rctx.color(d, ph)), ColorRef::rgb(rctx.color(l, ph))));
|
|
std::borrow::Cow::Owned(out)
|
|
}
|
|
|
|
/// The paint of a gradient of `shape` with `stops` (position, colour) spanning `bounds`, faded
|
|
/// by `alpha`, ramping between stops as PowerPoint does (see `ramp`).
|
|
pub fn gradient(shape: &GradientShape, mut stops: Vec<(f64, Rgba)>, bounds: Rect, alpha: f64) -> peniko::Gradient {
|
|
for s in &mut stops {
|
|
s.0 = s.0.clamp(0.0, 1.0);
|
|
}
|
|
stops.sort_by(|a, b| a.0.total_cmp(&b.0));
|
|
let stops: Vec<peniko::ColorStop> =
|
|
crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
|
|
match shape {
|
|
GradientShape::Linear { angle, .. } => {
|
|
// Angle measured clockwise from left→right; span the bounds along that direction.
|
|
let a = angle.to_radians();
|
|
let (dx, dy) = (a.cos(), a.sin());
|
|
let c = bounds.center();
|
|
let half = (bounds.width() * dx.abs() + bounds.height() * dy.abs()) / 2.0;
|
|
peniko::Gradient::new_linear(Point::new(c.x - dx * half, c.y - dy * half), Point::new(c.x + dx * half, c.y + dy * half))
|
|
.with_stops(stops.as_slice())
|
|
}
|
|
GradientShape::Path { focus, .. } => {
|
|
let fx = bounds.x0 + bounds.width() * (focus[0] + (1.0 - focus[2])) / 2.0;
|
|
let fy = bounds.y0 + bounds.height() * (focus[1] + (1.0 - focus[3])) / 2.0;
|
|
// Reach the farthest corner, so a gradient from a corner covers the whole box.
|
|
let r = [(bounds.x0, bounds.y0), (bounds.x1, bounds.y0), (bounds.x0, bounds.y1), (bounds.x1, bounds.y1)]
|
|
.iter()
|
|
.map(|(x, y)| ((x - fx).powi(2) + (y - fy).powi(2)).sqrt())
|
|
.fold(1e-6, f64::max);
|
|
peniko::Gradient::new_radial(Point::new(fx, fy), r as f32).with_stops(stops.as_slice())
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Draw a picture fill into `bounds` (shape-local) honouring crop and stretch/tile modes; an animated
|
|
/// GIF shows its frame at `gif_time` seconds.
|
|
pub fn picture(ctx: &mut RenderContext, pres: &Presentation, pf: &PictureFill, bounds: Rect, m: Affine, gif_time: Option<f64>) {
|
|
let Some(item) = pres.media(pf.media) else {
|
|
missing(ctx, bounds);
|
|
return;
|
|
};
|
|
let px_scale = crate::scale_of(m);
|
|
let want = (bounds.width().max(bounds.height()) * px_scale).max(1.0);
|
|
let frame = gif_time.and_then(|t| images::gif_pixmap(&item.data, &pf.adjust, t));
|
|
let Some(pm) = frame.or_else(|| images::decode_for(&item.data, want, &pf.adjust)) else {
|
|
missing(ctx, bounds);
|
|
return;
|
|
};
|
|
let (iw, ih) = (pm.width() as f64, pm.height() as f64);
|
|
if iw < 1.0 || ih < 1.0 {
|
|
return;
|
|
}
|
|
let dest = match &pf.mode {
|
|
PictureMode::Stretch { fill_rect } => {
|
|
let [l, t, r, b] = *fill_rect;
|
|
let inner = Rect::new(
|
|
bounds.x0 + l * bounds.width(),
|
|
bounds.y0 + t * bounds.height(),
|
|
bounds.x1 - r * bounds.width(),
|
|
bounds.y1 - b * bounds.height(),
|
|
);
|
|
crate::crop_dest(inner, pf.crop)
|
|
}
|
|
PictureMode::Tile { .. } => bounds,
|
|
};
|
|
let alpha = pf.alpha.unwrap_or(1.0).clamp(0.0, 1.0);
|
|
let image = vello_cpu::Image {
|
|
image: vello_cpu::ImageSource::Pixmap(pm.clone()),
|
|
sampler: peniko::ImageSampler { quality: peniko::ImageQuality::High, ..Default::default() },
|
|
};
|
|
if let PictureMode::Tile { sx, sy, tx, ty, .. } = &pf.mode {
|
|
let (sx, sy) = (if *sx > 0.0 { *sx } else { 1.0 }, if *sy > 0.0 { *sy } else { 1.0 });
|
|
let tile_w = iw * 0.75 * sx;
|
|
let tile_h = ih * 0.75 * sy;
|
|
let nx = ((bounds.width() / tile_w.max(1.0)).ceil() as i64).clamp(0, 200);
|
|
let ny = ((bounds.height() / tile_h.max(1.0)).ceil() as i64).clamp(0, 200);
|
|
for j in -1..=ny {
|
|
for i in -1..=nx {
|
|
let r = Rect::new(bounds.x0 + tx + i as f64 * tile_w, bounds.y0 + ty + j as f64 * tile_h, 0.0, 0.0);
|
|
let r = Rect::new(r.x0, r.y0, r.x0 + tile_w, r.y0 + tile_h);
|
|
draw_image(ctx, &image, iw, ih, r, m, alpha);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
draw_image(ctx, &image, iw, ih, dest, m, alpha);
|
|
}
|
|
|
|
fn draw_image(ctx: &mut RenderContext, image: &vello_cpu::Image, iw: f64, ih: f64, dest: Rect, m: Affine, alpha: f64) {
|
|
let t = m * Affine::translate(dest.origin().to_vec2()) * Affine::scale_non_uniform(dest.width() / iw, dest.height() / ih);
|
|
ctx.set_transform(t);
|
|
if alpha < 0.999 {
|
|
ctx.push_layer(None, None, Some(alpha as f32), None, None);
|
|
}
|
|
ctx.set_paint(image.clone());
|
|
ctx.fill_rect(&Rect::new(0.0, 0.0, iw, ih));
|
|
if alpha < 0.999 {
|
|
ctx.pop_layer();
|
|
}
|
|
}
|
|
|
|
fn missing(ctx: &mut RenderContext, b: Rect) {
|
|
ctx.set_paint(peniko::Color::from_rgba8(230, 230, 230, 255));
|
|
ctx.fill_rect(&b);
|
|
ctx.set_paint(peniko::Color::from_rgba8(160, 160, 160, 255));
|
|
ctx.set_stroke(kurbo::Stroke::new(1.0));
|
|
let mut p = BezPath::new();
|
|
p.move_to((b.x0, b.y0));
|
|
p.line_to((b.x1, b.y1));
|
|
p.move_to((b.x1, b.y0));
|
|
p.line_to((b.x0, b.y1));
|
|
ctx.stroke_path(&p);
|
|
}
|
|
|
|
/// The speaker / film glyph on audio and video objects without a poster.
|
|
pub fn media_glyph(ctx: &mut RenderContext, video: bool, b: Rect) {
|
|
let s = b.width().min(b.height());
|
|
let c = b.center();
|
|
if video {
|
|
let r = s * 0.18;
|
|
ctx.set_paint(peniko::Color::from_rgba8(255, 255, 255, 220));
|
|
ctx.fill_path(&kurbo::Circle::new(c, r * 1.4).to_path(0.1));
|
|
let mut tri = BezPath::new();
|
|
tri.move_to((c.x - r * 0.45, c.y - r * 0.7));
|
|
tri.line_to((c.x + r * 0.75, c.y));
|
|
tri.line_to((c.x - r * 0.45, c.y + r * 0.7));
|
|
tri.close_path();
|
|
ctx.set_paint(peniko::Color::from_rgba8(30, 30, 30, 255));
|
|
ctx.fill_path(&tri);
|
|
return;
|
|
}
|
|
let k = s / 48.0;
|
|
let mut p = BezPath::new();
|
|
p.move_to((c.x - 14.0 * k, c.y - 6.0 * k));
|
|
p.line_to((c.x - 6.0 * k, c.y - 6.0 * k));
|
|
p.line_to((c.x + 4.0 * k, c.y - 15.0 * k));
|
|
p.line_to((c.x + 4.0 * k, c.y + 15.0 * k));
|
|
p.line_to((c.x - 6.0 * k, c.y + 6.0 * k));
|
|
p.line_to((c.x - 14.0 * k, c.y + 6.0 * k));
|
|
p.close_path();
|
|
ctx.set_paint(peniko::Color::from_rgba8(0x2E, 0x6F, 0xD8, 255));
|
|
ctx.fill_path(&p);
|
|
let mut w = BezPath::new();
|
|
for r in [9.0, 15.0] {
|
|
let arc = kurbo::Arc::new((c.x + 4.0 * k, c.y), (r * k, r * k), -0.8, 1.6, 0.0);
|
|
w.extend(arc.path_elements(0.1));
|
|
}
|
|
ctx.set_stroke(kurbo::Stroke::new(2.5 * k).with_caps(kurbo::Cap::Round));
|
|
ctx.stroke_path(&w);
|
|
}
|
|
|
|
/// A content-type icon drawn in empty picture/chart/table placeholders.
|
|
pub fn placeholder_icon(ctx: &mut RenderContext, kind: PhType, b: Rect) {
|
|
let s = (b.width().min(b.height()) * 0.18).clamp(10.0, 48.0);
|
|
let c = Point::new(b.center().x, b.center().y - s * 0.3);
|
|
let r = Rect::new(c.x - s / 2.0, c.y - s / 2.0, c.x + s / 2.0, c.y + s / 2.0);
|
|
ctx.set_paint(peniko::Color::from_rgba8(0x8C, 0x8C, 0x8C, 255));
|
|
ctx.set_stroke(kurbo::Stroke::new(s * 0.06).with_join(kurbo::Join::Round));
|
|
match kind {
|
|
PhType::Chart => {
|
|
for (i, h) in [0.45, 0.8, 0.6].iter().enumerate() {
|
|
let x = r.x0 + s * (0.1 + 0.3 * i as f64);
|
|
ctx.fill_rect(&Rect::new(x, r.y1 - s * h, x + s * 0.2, r.y1));
|
|
}
|
|
}
|
|
PhType::Table => {
|
|
ctx.stroke_path(&r.to_path(0.1));
|
|
let mut p = BezPath::new();
|
|
for k in 1..3 {
|
|
let x = r.x0 + s * k as f64 / 3.0;
|
|
let y = r.y0 + s * k as f64 / 3.0;
|
|
p.move_to((x, r.y0));
|
|
p.line_to((x, r.y1));
|
|
p.move_to((r.x0, y));
|
|
p.line_to((r.x1, y));
|
|
}
|
|
ctx.stroke_path(&p);
|
|
}
|
|
_ => {
|
|
ctx.stroke_path(&r.to_path(0.1));
|
|
let mut m = BezPath::new();
|
|
m.move_to((r.x0, r.y1));
|
|
m.line_to((r.x0 + s * 0.35, r.y0 + s * 0.45));
|
|
m.line_to((r.x0 + s * 0.6, r.y0 + s * 0.7));
|
|
m.line_to((r.x0 + s * 0.75, r.y0 + s * 0.55));
|
|
m.line_to((r.x1, r.y1));
|
|
m.close_path();
|
|
ctx.fill_path(&m);
|
|
ctx.fill_path(&kurbo::Circle::new((r.x0 + s * 0.72, r.y0 + s * 0.25), s * 0.1).to_path(0.1));
|
|
}
|
|
}
|
|
}
|