mirror of
https://github.com/storytold/figcraft.git
synced 2026-10-30 13:26:54 -06:00
550 lines
26 KiB
Rust
550 lines
26 KiB
Rust
use super::*;
|
|
use figcraft_color::{Color, ColorStop, Gradient, GradientKind, Paint};
|
|
use figcraft_doc::{Effect, EffectKind, NodeKind, Region, Segment, Shadow, StrokeAlign, TextData, VectorNetwork, Vertex, WindingRule};
|
|
|
|
fn px(p: &Pixmap, x: u32, y: u32) -> [u8; 4] {
|
|
let i = ((y * p.width() + x) * 4) as usize;
|
|
let d = &p.data()[i..i + 4];
|
|
[d[0], d[1], d[2], d[3]]
|
|
}
|
|
|
|
fn doc_with_rect(fill: Color) -> (figcraft_doc::Document, figcraft_doc::NodeId, figcraft_doc::NodeId) {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let r = d.create(p, NodeKind::Rectangle, "R", 10.0, 10.0, 50.0, 30.0).unwrap();
|
|
d.get_mut(r).unwrap().fills = vec![Paint::solid(fill)];
|
|
(d, p, r)
|
|
}
|
|
|
|
fn view(w: u32, h: u32) -> View {
|
|
View { origin: (0.0, 0.0), scale: 1.0, width: w, height: h }
|
|
}
|
|
|
|
#[test]
|
|
fn solid_rect_and_page_background() {
|
|
let (d, p, _) = doc_with_rect(Color::from_hex("FF0000").unwrap());
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 30, 20), [255, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 5, 5), [0xF5, 0xF5, 0xF5, 255]);
|
|
}
|
|
|
|
#[test]
|
|
fn vector_regions_use_their_own_paints_and_empty_regions_do_not_erase() {
|
|
let mut d = figcraft_doc::Document::new("regions");
|
|
let page = d.first_page().unwrap();
|
|
let network = VectorNetwork {
|
|
vertices: [(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0), (10.0, 0.0), (20.0, 0.0), (20.0, 10.0), (10.0, 10.0)]
|
|
.into_iter()
|
|
.map(|(x, y)| Vertex::new(x, y))
|
|
.collect(),
|
|
segments: (0..8).map(|i| Segment::line(i, (i + 1) % 4 + (i / 4) * 4)).collect(),
|
|
regions: vec![
|
|
Region {
|
|
loops: vec![vec![0, 1, 2, 3]],
|
|
winding: WindingRule::NonZero,
|
|
fills: Some(vec![Paint::solid(Color::from_hex("FF0000").unwrap())]),
|
|
..Default::default()
|
|
},
|
|
Region {
|
|
loops: vec![vec![4, 5, 6, 7]],
|
|
winding: WindingRule::NonZero,
|
|
fills: Some(vec![Paint::solid(Color::from_hex("0000FF").unwrap())]),
|
|
..Default::default()
|
|
},
|
|
Region { loops: vec![vec![0, 1, 2, 3]], winding: WindingRule::NonZero, fills: Some(vec![]), ..Default::default() },
|
|
],
|
|
};
|
|
let id = d.create(page, NodeKind::Vector { network }, "V", 10.0, 10.0, 20.0, 10.0).unwrap();
|
|
d.get_mut(id).unwrap().fills.clear();
|
|
let pix = render_view(&d, page, &view(40, 30), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
assert_eq!(px(&pix, 15, 15), [255, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 25, 15), [0, 0, 255, 255]);
|
|
assert_eq!(d.get(id).unwrap().fills.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn region_paint_space_preserves_gradient_image_and_pattern_placement() {
|
|
use figcraft_color::{ImageScaleMode, PaintKind, PatternPaint};
|
|
use figcraft_doc::RegionPaintSpace;
|
|
use figcraft_geom::{Affine, Rect, Shape};
|
|
|
|
let mut d = Document::new("paint frames");
|
|
let page = d.first_page().unwrap();
|
|
let tile = d.create(page, NodeKind::Rectangle, "Tile", 500.0, 500.0, 8.0, 6.0).unwrap();
|
|
d.get_mut(tile).unwrap().fills = vec![Paint::solid(Color::from_hex("F05020").unwrap())];
|
|
let mut image = Pixmap::new(8, 4).unwrap();
|
|
for (i, pixel) in image.pixels_mut().iter_mut().enumerate() {
|
|
*pixel = tiny_skia::PremultipliedColorU8::from_rgba((i % 8 * 30) as u8, (i / 8 * 60) as u8, 30, 255).unwrap();
|
|
}
|
|
d.images.insert(
|
|
"region-frame-image".into(),
|
|
figcraft_doc::ImageData { bytes: std::sync::Arc::new(encode_png(&image).unwrap()), width: 8, height: 4 },
|
|
);
|
|
let mut pattern = PatternPaint::new(tile.0);
|
|
pattern.spacing = (3.0, 4.0);
|
|
let paints = [
|
|
Paint::gradient(Gradient::default_for(GradientKind::Linear, Color::BLACK)),
|
|
Paint::image("region-frame-image", ImageScaleMode::Fill),
|
|
Paint::image("region-frame-image", ImageScaleMode::Tile),
|
|
Paint { kind: PaintKind::Pattern(pattern), ..Paint::solid(Color::WHITE) },
|
|
];
|
|
let frame = Affine::translate((35.0, 25.0)) * Affine::rotate(0.3);
|
|
let id = d.create(page, NodeKind::Rectangle, "Source", 0.0, 0.0, 60.0, 30.0).unwrap();
|
|
for paint in paints {
|
|
let n = d.get_mut(id).unwrap();
|
|
n.kind = NodeKind::Rectangle;
|
|
n.transform = frame;
|
|
n.width = 60.0;
|
|
n.height = 30.0;
|
|
n.fills = vec![paint.clone()];
|
|
let before = render_view(&d, page, &view(120, 100), &Options::default()).unwrap();
|
|
let mut path = Rect::new(0.0, 0.0, 60.0, 30.0).to_path(0.1);
|
|
path.apply_affine(frame);
|
|
let mut network = VectorNetwork::from_path(&path);
|
|
for region in &mut network.regions {
|
|
region.fills = Some(vec![paint.clone()]);
|
|
region.paint_space = Some(RegionPaintSpace { width: 60.0, height: 30.0, transform: frame });
|
|
}
|
|
let n = d.get_mut(id).unwrap();
|
|
n.kind = NodeKind::Vector { network };
|
|
n.transform = Affine::IDENTITY;
|
|
n.width = 120.0;
|
|
n.height = 100.0;
|
|
n.fills.clear();
|
|
let after = render_view(&d, page, &view(120, 100), &Options::default()).unwrap();
|
|
for (a, b) in before.data().iter().zip(after.data()) {
|
|
assert!(a.abs_diff(*b) <= 1, "paint moved after reboxing: {:?}", paint.kind);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn styled_vector_mask_unions_region_windings_and_excludes_unpainted_regions() {
|
|
let mut d = figcraft_doc::Document::new("region mask");
|
|
let page = d.first_page().unwrap();
|
|
let group = d.create(page, NodeKind::Group, "Mask group", 0.0, 0.0, 60.0, 20.0).unwrap();
|
|
let mut network = VectorNetwork::default();
|
|
let mut regions = Vec::new();
|
|
for x in [0.0, 10.0, 30.0, 40.0, 50.0] {
|
|
let v = network.vertices.len();
|
|
network.vertices.extend([(x, 0.0), (x + 20.0, 0.0), (x + 20.0, 20.0), (x, 20.0)].map(|(x, y)| Vertex::new(x, y)));
|
|
let s = network.segments.len();
|
|
network.segments.extend((0..4).map(|i| Segment::line(v + i, v + (i + 1) % 4)));
|
|
let fills = match regions.len() {
|
|
0 => Some(vec![Paint::solid(Color::from_hex("FF0000").unwrap())]),
|
|
1 => Some(vec![Paint::solid(Color::from_hex("0000FF").unwrap())]),
|
|
2 => Some(vec![Paint { visible: false, ..Paint::solid(Color::from_hex("00FF00").unwrap()) }]),
|
|
3 => None,
|
|
_ => Some(Vec::new()),
|
|
};
|
|
regions.push(Region {
|
|
loops: vec![(s..s + 4).collect()],
|
|
winding: if regions.len() == 1 { WindingRule::EvenOdd } else { WindingRule::NonZero },
|
|
fills,
|
|
..Default::default()
|
|
});
|
|
}
|
|
network.regions = regions;
|
|
let mask = d.create(group, NodeKind::Vector { network }, "Mask", 0.0, 0.0, 60.0, 20.0).unwrap();
|
|
{
|
|
let n = d.get_mut(mask).unwrap();
|
|
n.fills.clear();
|
|
n.is_mask = true;
|
|
n.mask_type = figcraft_doc::MaskType::Vector;
|
|
}
|
|
let content = d.create(group, NodeKind::Rectangle, "Content", 0.0, 0.0, 60.0, 20.0).unwrap();
|
|
d.get_mut(content).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
let pix = render_view(&d, page, &view(60, 20), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
assert_eq!(px(&pix, 5, 10), [0, 0, 0, 255], "visible left region masks");
|
|
assert_eq!(px(&pix, 15, 10), [0, 0, 0, 255], "overlap remains in union despite mixed winding");
|
|
assert_eq!(px(&pix, 35, 10), [255, 255, 255, 255], "hidden region excluded from styled silhouette");
|
|
assert_eq!(px(&pix, 45, 10), [255, 255, 255, 255], "unpainted inherited region excluded");
|
|
assert_eq!(px(&pix, 55, 10), [255, 255, 255, 255], "explicit-empty region excluded");
|
|
}
|
|
|
|
#[test]
|
|
fn inherited_paint_frames_keep_overlapping_regions_in_vector_masks() {
|
|
use figcraft_geom::{Affine, Point, Shape};
|
|
|
|
let mut d = Document::new("inherited region mask");
|
|
let page = d.first_page().unwrap();
|
|
let group = d.create(page, NodeKind::Group, "Mask group", 0.0, 0.0, 40.0, 20.0).unwrap();
|
|
let mut network = VectorNetwork::default();
|
|
for x in [0.0, 10.0] {
|
|
let v = network.vertices.len();
|
|
let s = network.segments.len();
|
|
network.vertices.extend([(x, 0.0), (x + 20.0, 0.0), (x + 20.0, 20.0), (x, 20.0)].map(|(x, y)| Vertex::new(x, y)));
|
|
network.segments.extend((0..4).map(|i| Segment::line(v + i, v + (i + 1) % 4)));
|
|
network.regions.push(Region {
|
|
loops: vec![(s..s + 4).collect()],
|
|
winding: WindingRule::EvenOdd,
|
|
fills: None,
|
|
paint_space: Some(figcraft_doc::RegionPaintSpace { width: 20.0, height: 20.0, transform: Affine::translate((x, 0.0)) }),
|
|
});
|
|
}
|
|
let mask = d.create(group, NodeKind::Vector { network }, "Mask", 0.0, 0.0, 30.0, 20.0).unwrap();
|
|
let n = d.get_mut(mask).unwrap();
|
|
n.fills = vec![Paint::solid(Color::BLACK)];
|
|
n.is_mask = true;
|
|
n.mask_type = figcraft_doc::MaskType::Vector;
|
|
let (outline, rule) = node_outline(&d, d.node(mask).unwrap()).unwrap();
|
|
assert_eq!(rule, FillRule::Winding);
|
|
assert_ne!(outline.winding(Point::new(15.0, 10.0)), 0, "independent inherited regions retain their overlap");
|
|
let content = d.create(group, NodeKind::Rectangle, "Content", 0.0, 0.0, 40.0, 20.0).unwrap();
|
|
d.get_mut(content).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
let pix = render_view(&d, page, &view(40, 20), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
for x in [5, 15, 25] {
|
|
assert_eq!(px(&pix, x, 10), [0, 0, 0, 255]);
|
|
}
|
|
assert_eq!(px(&pix, 35, 10), [255, 255, 255, 255]);
|
|
}
|
|
|
|
#[test]
|
|
fn zoom_scales() {
|
|
let (d, p, _) = doc_with_rect(Color::BLACK);
|
|
let v = View { origin: (0.0, 0.0), scale: 2.0, width: 200, height: 200 };
|
|
let pix = render_view(&d, p, &v, &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 100, 60)[3], 255);
|
|
assert_eq!(px(&pix, 118, 78), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 125, 60)[0], 0xF5);
|
|
}
|
|
|
|
#[test]
|
|
fn opacity_and_layer() {
|
|
let (mut d, p, r) = doc_with_rect(Color::BLACK);
|
|
d.get_mut(r).unwrap().opacity = 0.5;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
let v = px(&pix, 30, 20)[0];
|
|
assert!((120..=135).contains(&v), "{v}");
|
|
}
|
|
|
|
#[test]
|
|
fn drop_shadow_paints_outside() {
|
|
let (mut d, p, r) = doc_with_rect(Color::WHITE);
|
|
d.get_mut(r).unwrap().effects.push(Effect {
|
|
kind: EffectKind::DropShadow(Shadow { color: Color::BLACK, offset: (0.0, 10.0), radius: 0.0, ..Default::default() }),
|
|
visible: true,
|
|
});
|
|
let pix = render_view(&d, p, &view(100, 100), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
// Below the rect (y 40..50) is shadow.
|
|
assert!(px(&pix, 30, 45)[0] < 30, "{:?}", px(&pix, 30, 45));
|
|
// The rect itself stays white.
|
|
assert_eq!(px(&pix, 30, 20)[0], 255);
|
|
}
|
|
|
|
#[test]
|
|
fn inner_shadow_and_blur_dont_crash() {
|
|
let (mut d, p, r) = doc_with_rect(Color::WHITE);
|
|
let n = d.get_mut(r).unwrap();
|
|
n.effects.push(Effect::inner_shadow());
|
|
n.effects.push(Effect::layer_blur());
|
|
n.effects.push(Effect::background_blur());
|
|
n.effects.push(Effect {
|
|
kind: EffectKind::Noise(figcraft_doc::Noise { size: 1.0, density: 0.5, color: Color::BLACK, ..Default::default() }),
|
|
visible: true,
|
|
});
|
|
let _ = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn gradients_render() {
|
|
for kind in [GradientKind::Linear, GradientKind::Radial, GradientKind::Angular, GradientKind::Diamond] {
|
|
let (mut d, p, r) = doc_with_rect(Color::BLACK);
|
|
let g = Gradient {
|
|
kind,
|
|
stops: vec![
|
|
ColorStop { position: 0.0, color: Color::from_hex("FF0000").unwrap() },
|
|
ColorStop { position: 1.0, color: Color::from_hex("0000FF").unwrap() },
|
|
],
|
|
from: (0.0, 0.5),
|
|
to: (1.0, 0.5),
|
|
width: (0.0, 1.0),
|
|
};
|
|
let g = if kind == GradientKind::Linear { g } else { Gradient { from: (0.5, 0.5), to: (1.0, 0.5), width: (0.5, 1.0), ..g } };
|
|
d.get_mut(r).unwrap().fills = vec![Paint::gradient(g)];
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
let left = px(&pix, if kind == GradientKind::Linear { 11 } else { 35 }, 25);
|
|
let right = px(&pix, 58, 25);
|
|
assert_ne!(left, right, "{kind:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn frame_clips_children() {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 50.0, 50.0).unwrap();
|
|
let r = d.create(f, NodeKind::Rectangle, "R", 25.0, 25.0, 50.0, 50.0).unwrap();
|
|
d.get_mut(r).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 40, 40), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 60, 60)[0], 0xF5);
|
|
d.get_mut(f).unwrap().clip = false;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 60, 60), [0, 0, 0, 255]);
|
|
}
|
|
|
|
#[test]
|
|
fn strokes_align() {
|
|
let (mut d, p, r) = doc_with_rect(Color::WHITE);
|
|
let n = d.get_mut(r).unwrap();
|
|
n.strokes = vec![Paint::solid(Color::BLACK)];
|
|
n.stroke.weight = 4.0;
|
|
n.stroke.align = StrokeAlign::Outside;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 30, 8), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 30, 12), [255, 255, 255, 255]);
|
|
d.get_mut(r).unwrap().stroke.align = StrokeAlign::Inside;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 30, 12), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 30, 8)[0], 0xF5);
|
|
}
|
|
|
|
#[test]
|
|
fn side_strokes_follow_rounded_corners() {
|
|
// border-l-4 rounded-r-lg: a straight 4 px bar on the left, nothing on the other edges.
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let f = d.create(p, NodeKind::Frame, "F", 10.0, 10.0, 120.0, 60.0).unwrap();
|
|
let n = d.get_mut(f).unwrap();
|
|
n.fills = vec![Paint::solid(Color::WHITE)];
|
|
n.corners.radii = [0.0, 8.0, 8.0, 0.0];
|
|
n.strokes = vec![Paint::solid(Color::BLACK)];
|
|
n.stroke.align = StrokeAlign::Inside;
|
|
n.stroke.sides = Some([0.0, 0.0, 0.0, 4.0]);
|
|
let pix = render_view(&d, p, &view(150, 80), &Options::default()).unwrap();
|
|
for x in 10..14 {
|
|
assert_eq!(px(&pix, x, 40), [0, 0, 0, 255], "x {x}");
|
|
}
|
|
for (x, y) in [(14, 40), (129, 40), (126, 12), (126, 67), (70, 10), (70, 69)] {
|
|
assert_eq!(px(&pix, x, y), [255, 255, 255, 255], "({x}, {y})");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn mask_clips_siblings() {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let g = d.create(p, NodeKind::Group, "G", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
let m = d.create(g, NodeKind::Ellipse { start: 0.0, sweep: std::f64::consts::TAU, inner: 0.0 }, "M", 0.0, 0.0, 50.0, 50.0).unwrap();
|
|
d.get_mut(m).unwrap().is_mask = true;
|
|
let r = d.create(g, NodeKind::Rectangle, "R", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
d.get_mut(r).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 25, 25), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 2, 2)[0], 0xF5);
|
|
assert_eq!(px(&pix, 80, 80)[0], 0xF5);
|
|
}
|
|
|
|
#[test]
|
|
fn luminance_and_vector_masks() {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let g = d.create(p, NodeKind::Group, "G", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
// The mask: white on the left half, black on the right.
|
|
let m = d.create(g, NodeKind::Rectangle, "M", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
let grad = figcraft_color::Gradient {
|
|
kind: figcraft_color::GradientKind::Linear,
|
|
stops: vec![
|
|
figcraft_color::ColorStop { position: 0.0, color: Color::WHITE },
|
|
figcraft_color::ColorStop { position: 0.49, color: Color::WHITE },
|
|
figcraft_color::ColorStop { position: 0.51, color: Color::BLACK },
|
|
figcraft_color::ColorStop { position: 1.0, color: Color::BLACK },
|
|
],
|
|
from: (0.0, 0.5),
|
|
to: (1.0, 0.5),
|
|
width: (0.0, 1.0),
|
|
};
|
|
d.get_mut(m).unwrap().fills = vec![Paint::gradient(grad)];
|
|
d.get_mut(m).unwrap().is_mask = true;
|
|
let r = d.create(g, NodeKind::Rectangle, "R", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
d.get_mut(r).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
// Alpha: the mask is opaque everywhere, so everything shows.
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 80, 50), [0, 0, 0, 255]);
|
|
// Luminance: only the white half shows.
|
|
d.get_mut(m).unwrap().mask_type = figcraft_doc::MaskType::Luminance;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 20, 50), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 80, 50)[0], 0xF5, "black hides");
|
|
// Vector: a fully transparent ellipse still masks by its outline.
|
|
let e = d.create(g, NodeKind::Ellipse { start: 0.0, sweep: std::f64::consts::TAU, inner: 0.0 }, "E", 0.0, 0.0, 50.0, 50.0).unwrap();
|
|
d.get_mut(e).unwrap().fills = vec![Paint::solid(Color::new(0.0, 0.0, 0.0, 0.0))];
|
|
d.get_mut(e).unwrap().is_mask = true;
|
|
d.get_mut(e).unwrap().mask_type = figcraft_doc::MaskType::Vector;
|
|
d.get_mut(g).unwrap().children = vec![e, r];
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 25, 25), [0, 0, 0, 255], "inside the outline");
|
|
assert_eq!(px(&pix, 80, 80)[0], 0xF5, "outside");
|
|
// As an alpha mask the transparent ellipse hides everything.
|
|
d.get_mut(e).unwrap().mask_type = figcraft_doc::MaskType::Alpha;
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 25, 25)[0], 0xF5);
|
|
}
|
|
|
|
#[test]
|
|
fn boolean_subtract_renders_hole() {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let b = d.create(p, NodeKind::BooleanOp { op: figcraft_doc::BoolOp::Subtract }, "B", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
d.get_mut(b).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
d.create(b, NodeKind::Rectangle, "A", 0.0, 0.0, 100.0, 100.0).unwrap();
|
|
d.create(b, NodeKind::Rectangle, "Hole", 25.0, 25.0, 50.0, 50.0).unwrap();
|
|
let pix = render_view(&d, p, &view(100, 100), &Options::default()).unwrap();
|
|
assert_eq!(px(&pix, 10, 10), [0, 0, 0, 255]);
|
|
assert_eq!(px(&pix, 50, 50)[0], 0xF5);
|
|
}
|
|
|
|
#[test]
|
|
fn text_renders_something() {
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let mut td = TextData::new("Hello");
|
|
td.style.font_size = 32.0;
|
|
d.create(p, NodeKind::Text(td), "T", 0.0, 0.0, 200.0, 50.0).unwrap();
|
|
let pix = render_view(&d, p, &view(200, 60), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
let dark = pix.data().as_chunks::<4>().0.iter().filter(|c| c[0] < 100).count();
|
|
if figcraft_text::find_face("Inter", "Regular").is_some() {
|
|
assert!(dark > 50, "{dark}");
|
|
}
|
|
}
|
|
|
|
/// The machine's colour emoji face, if it has one (this test skips without: no font ships here).
|
|
fn emoji_face() -> Option<(String, String)> {
|
|
figcraft_text::scan_system_fonts();
|
|
let mut db = figcraft_text::db().write().unwrap();
|
|
db.emoji_fallbacks().into_iter().find(|f| f.has_color()).map(|f| (f.family.clone(), f.style.clone()))
|
|
}
|
|
|
|
#[test]
|
|
fn colour_emoji_draw_their_pixels() {
|
|
let Some((family, style)) = emoji_face() else { return };
|
|
let mut d = figcraft_doc::Document::new("t");
|
|
let p = d.first_page().unwrap();
|
|
let mut td = TextData::new("\u{1F600}");
|
|
(td.style.font_family, td.style.font_style) = (family.clone(), style.clone());
|
|
td.style.font_size = 48.0;
|
|
d.create(p, NodeKind::Text(td), "T", 0.0, 0.0, 200.0, 64.0).unwrap();
|
|
let pix = render_view(&d, p, &view(100, 80), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
// The emoji is the only thing in this document that paints saturated colour.
|
|
let coloured = pix
|
|
.data()
|
|
.as_chunks::<4>()
|
|
.0
|
|
.iter()
|
|
.filter(|c| {
|
|
let (r, g, b) = (i16::from(c[0]), i16::from(c[1]), i16::from(c[2]));
|
|
c[3] == 255 && (r.max(g).max(b) - r.min(g).min(b)) > 60
|
|
})
|
|
.count();
|
|
assert!(coloured > 200, "{family} drew {coloured} coloured pixels");
|
|
}
|
|
|
|
#[test]
|
|
fn export_png_roundtrip() {
|
|
let (d, _, r) = doc_with_rect(Color::from_hex("00FF00").unwrap());
|
|
let pix = render_node(&d, r, 2.0).unwrap();
|
|
assert_eq!((pix.width(), pix.height()), (100, 60));
|
|
let png = encode_png(&pix).unwrap();
|
|
let back = image::load_from_memory(&png).unwrap().to_rgba8();
|
|
assert_eq!(back.get_pixel(50, 30).0, [0, 255, 0, 255]);
|
|
let _ = encode_jpeg(&pix, Color::WHITE, 90).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn exports_carry_the_colour_profile() {
|
|
use figcraft_color::ColorProfile;
|
|
use figcraft_doc::ExportFormat;
|
|
use image::ImageDecoder;
|
|
let (d, _, r) = doc_with_rect(Color::from_hex("00FF00").unwrap());
|
|
let pix = render_node(&d, r, 1.0).unwrap();
|
|
for profile in ColorProfile::ALL {
|
|
let png = encode_export(&pix, ExportFormat::Png, profile).unwrap();
|
|
// The inserted chunk has a valid CRC: the decoder accepts the file and keeps the pixels.
|
|
let mut dec = image::codecs::png::PngDecoder::new(std::io::Cursor::new(&png)).unwrap();
|
|
let icc = dec.icc_profile().unwrap();
|
|
assert_eq!(icc.is_some(), !profile.is_srgb(), "{profile:?}");
|
|
assert_eq!(image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(5, 5).0, [0, 255, 0, 255]);
|
|
for f in [ExportFormat::Jpg, ExportFormat::Webp] {
|
|
assert!(!encode_export(&pix, f, profile).unwrap().is_empty());
|
|
}
|
|
assert!(encode_export(&pix, ExportFormat::Svg, profile).is_err());
|
|
}
|
|
assert_eq!(png_insert_chunk(b"not a png".to_vec(), b"sRGB", &[0]), b"not a png");
|
|
}
|
|
|
|
#[test]
|
|
fn images_are_managed_into_the_file_profile() {
|
|
use figcraft_color::{ColorProfile, ImageScaleMode, Paint};
|
|
let (mut d, _, r) = doc_with_rect(Color::WHITE);
|
|
let mut red = Pixmap::new(4, 4).unwrap();
|
|
red.fill(tiny_skia::Color::from_rgba8(255, 0, 0, 255));
|
|
d.images.insert("red".into(), figcraft_doc::ImageData { bytes: std::sync::Arc::new(encode_png(&red).unwrap()), width: 4, height: 4 });
|
|
d.get_mut(r).unwrap().fills = vec![Paint::image("red", ImageScaleMode::Fill)];
|
|
let center = |d: &Document| {
|
|
let pix = render_node(d, r, 1.0).unwrap();
|
|
let (x, y) = (pix.width() / 2, pix.height() / 2);
|
|
let px = pix.pixel(x, y).unwrap();
|
|
(pix, [px.red(), px.green(), px.blue()])
|
|
};
|
|
assert_eq!(center(&d).1, [255, 0, 0]);
|
|
// In a Display P3 file the (sRGB) image is converted into P3 values…
|
|
d.color_profile = ColorProfile::DisplayP3;
|
|
let (mut pix, rgb) = center(&d);
|
|
assert!(rgb[0].abs_diff(234) <= 1 && rgb[1].abs_diff(51) <= 1 && rgb[2].abs_diff(35) <= 1, "{rgb:?}");
|
|
// …and comes back to the screen unchanged.
|
|
to_srgb(&mut pix, d.color_profile);
|
|
let px = pix.pixel(pix.width() / 2, pix.height() / 2).unwrap();
|
|
assert!(px.red() >= 254 && px.green() <= 1 && px.blue() <= 1, "{px:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn hostile_sizes() {
|
|
let (mut d, p, r) = doc_with_rect(Color::BLACK);
|
|
let n = d.get_mut(r).unwrap();
|
|
n.width = f64::NAN;
|
|
n.height = 1e12;
|
|
n.effects.push(Effect { kind: EffectKind::LayerBlur(figcraft_doc::Blur::uniform(1e9)), visible: true });
|
|
let _ = render_view(&d, p, &view(64, 64), &Options::default());
|
|
let _ = render_node(&d, r, f64::NAN);
|
|
let _ = render_view(&d, p, &View { origin: (f64::NAN, 0.0), scale: 0.0, width: 0, height: 0 }, &Options::default());
|
|
}
|
|
|
|
#[test]
|
|
fn inner_shadow_reaches_every_edge() {
|
|
let (mut d, p, r) = doc_with_rect(Color::WHITE);
|
|
d.get_mut(r).unwrap().effects.push(Effect {
|
|
kind: EffectKind::InnerShadow(Shadow { color: Color::BLACK, offset: (0.0, 4.0), radius: 8.0, ..Default::default() }),
|
|
visible: true,
|
|
});
|
|
let pix = render_view(&d, p, &view(100, 100), &Options { background: Some(Color::WHITE), ..Default::default() }).unwrap();
|
|
// Left edge (no offset that way) is still shaded; the centre is not.
|
|
assert!(px(&pix, 11, 25)[0] < 235, "{:?}", px(&pix, 11, 25));
|
|
assert!(px(&pix, 35, 30)[0] > 245);
|
|
}
|
|
|
|
#[test]
|
|
fn rect_clip_frame_matches_same_rect_fill_on_fractional_edges() {
|
|
let white = Options { background: Some(Color::WHITE), ..Default::default() };
|
|
for (x, y, w, h) in [(0.5, 0.5, 10.0, 10.0), (0.0, 0.0, 10.5, 10.5), (0.0, 0.0, 10.0, 10.0)] {
|
|
let mut clipped = figcraft_doc::Document::new("clipped");
|
|
let p = clipped.first_page().unwrap();
|
|
let f = clipped.create(p, NodeKind::Frame, "F", x, y, w, h).unwrap();
|
|
clipped.get_mut(f).unwrap().fills.clear();
|
|
clipped.get_mut(f).unwrap().clip = true;
|
|
let c = clipped.create(f, NodeKind::Rectangle, "C", -5.0, -5.0, w + 10.0, h + 10.0).unwrap();
|
|
clipped.get_mut(c).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
|
|
let mut direct = figcraft_doc::Document::new("direct");
|
|
let dp = direct.first_page().unwrap();
|
|
let r = direct.create(dp, NodeKind::Rectangle, "R", x, y, w, h).unwrap();
|
|
direct.get_mut(r).unwrap().fills = vec![Paint::solid(Color::BLACK)];
|
|
|
|
let a = render_view(&clipped, p, &view(12, 12), &white).unwrap();
|
|
let e = render_view(&direct, dp, &view(12, 12), &white).unwrap();
|
|
for (px_x, px_y) in [(0, 0), (0, 5), (5, 0), (5, 5), (10, 5), (5, 10), (10, 10), (11, 11)] {
|
|
assert_eq!(px(&a, px_x, px_y), px(&e, px_x, px_y), "frame {x},{y} {w}x{h} at ({px_x},{px_y})");
|
|
}
|
|
}
|
|
}
|