mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 18:27:02 -06:00
dotCooCoo
007f536c79
The renderer kept the art it made for an object's effects while the object stayed the same. In the web build, type that a geometry effect outlines, on its own, in a group or in a symbol's art, kept the substitute font's outlines after its own font loaded. On the desktop, Refresh Font List left them on a symbol instance whose art holds the type. Objects with Revolve, Extrude & Bevel, Inflate or Rotate, and objects and groups with a color adjustment, kept the colors they were shaded or recolored with after the color settings changed. Live objects already followed both. The renderer now keeps that art with the inputs it keeps for the art of live objects: the font generation when the art holds type, the art of the symbols it shows, and the color settings. A temporary release test timed the added key at 11 microseconds a frame for 400 type objects with a drop shadow and 0.77 ms for 400 symbol instances of 100 paths each with a drop shadow, against warm frames of 5.3 and 72 ms. Docs: docs/target-app-parity.md, docs/gaps.md.
304 lines
16 KiB
Rust
304 lines
16 KiB
Rust
//! Type redraws in a font that becomes available while it is on screen (fonts added, Refresh Font
|
|
//! List).
|
|
|
|
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
|
|
|
|
use vectorcraft_doc::text::{CharStyle, TextObject};
|
|
use vectorcraft_doc::{Node, NodeKind};
|
|
use vectorcraft_geom::Point;
|
|
|
|
use super::*;
|
|
|
|
/// Taken to add fonts. Renderers lay type out again when the fonts change, so tests of what they
|
|
/// keep between frames hold it shared ([`fonts_steady`]) and the tests here hold it alone.
|
|
static FONTS: RwLock<()> = RwLock::new(());
|
|
|
|
/// No fonts are added by these tests until the guard is dropped.
|
|
pub(crate) fn fonts_steady() -> RwLockReadGuard<'static, ()> {
|
|
// A test that failed holding it leaves nothing to undo.
|
|
FONTS.read().unwrap_or_else(PoisonError::into_inner)
|
|
}
|
|
|
|
/// No test holding [`fonts_steady`] runs until the guard is dropped.
|
|
fn adding_fonts() -> RwLockWriteGuard<'static, ()> {
|
|
FONTS.write().unwrap_or_else(PoisonError::into_inner)
|
|
}
|
|
|
|
/// The bundled Source Serif 4 renamed `family` (as long as the original name).
|
|
fn serif_as(family: &str) -> Vec<u8> {
|
|
let mut data = include_bytes!("../../../assets/fonts/SourceSerif4-Regular.ttf").to_vec();
|
|
let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
|
|
for (from, to) in [(utf16("Source Serif 4"), utf16(family)), (b"Source Serif 4".to_vec(), family.as_bytes().to_vec())] {
|
|
assert_eq!(from.len(), to.len());
|
|
let mut i = 0;
|
|
while let Some(at) = data[i..].windows(from.len()).position(|w| w == from) {
|
|
data[i + at..i + at + to.len()].copy_from_slice(&to);
|
|
i += at + to.len();
|
|
}
|
|
}
|
|
data
|
|
}
|
|
|
|
#[test]
|
|
fn type_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
const FAMILY: &str = "Arrival Serif4";
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let style = CharStyle { size: 60.0, font_family: FAMILY.into(), ..Default::default() };
|
|
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
|
|
n.id = d.alloc_id();
|
|
let l = d.layers[0].id;
|
|
d.insert(Some(l), 0, n).unwrap();
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
|
}
|
|
|
|
/// Type with raster effects redraws in a font that becomes available: its drop shadow and its
|
|
/// blurred content are made again.
|
|
#[test]
|
|
fn type_with_raster_effects_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
const FAMILY: &str = "Raster Serif 4";
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let l = d.layers[0].id;
|
|
let effects =
|
|
[("stylize.dropShadow", serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100})), ("blur.gaussian", serde_json::json!({"radius": 1}))];
|
|
for (i, (id, params)) in effects.into_iter().enumerate() {
|
|
let style = CharStyle { size: 50.0, font_family: FAMILY.into(), ..Default::default() };
|
|
let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 60.0 + 70.0 * i as f64), "Hamburg", style))));
|
|
n.appearance.effects.push(vectorcraft_doc::Effect { id: id.into(), params, visible: true });
|
|
d.insert(Some(l), i, n).unwrap();
|
|
}
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
|
}
|
|
|
|
/// Type with Variable Font settings is drawn in a face of their own, which is not a substitute:
|
|
/// Document Setup's highlight of substituted glyphs leaves it alone, and so does Highlight
|
|
/// Alternate Glyphs.
|
|
#[test]
|
|
fn variable_font_settings_are_not_highlighted_as_substituted_glyphs() {
|
|
use vectorcraft_text::test_fonts::{TWO_AXIS_FAMILY, two_axis_font};
|
|
let _adding = adding_fonts();
|
|
vectorcraft_text::FontDb::global().add_font(two_axis_font().unwrap());
|
|
let font_axes = [("wght".to_string(), 650.0)].into_iter().collect();
|
|
let style = CharStyle { size: 40.0, font_family: TWO_AXIS_FAMILY.into(), font_axes, ..Default::default() };
|
|
let t = TextObject::point(Point::new(10.0, 60.0), "lIn", style);
|
|
let g = text_geom(&t);
|
|
assert!(!g.all.elements().is_empty());
|
|
assert!(g.substituted_glyphs.elements().is_empty() && g.substituted_fonts.elements().is_empty());
|
|
assert!(g.alternate_glyphs(&t).elements().is_empty());
|
|
}
|
|
|
|
/// Type at 80% opacity, in Multiply and with a drop shadow redraws in a font that becomes
|
|
/// available: the glyph geometry kept for it is laid out again.
|
|
#[test]
|
|
fn translucent_blended_and_shadowed_type_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
const FAMILY: &str = "Blended Serif4";
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let l = d.layers[0].id;
|
|
for i in 0..3 {
|
|
let style = CharStyle { size: 36.0, font_family: FAMILY.into(), ..Default::default() };
|
|
let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 40.0 + 45.0 * i as f64), "Hamburg", style))));
|
|
match i {
|
|
0 => n.opacity = 0.8,
|
|
1 => n.blend = vectorcraft_color::BlendMode::Multiply,
|
|
_ => n.appearance.effects.push(vectorcraft_doc::Effect {
|
|
id: "stylize.dropShadow".into(),
|
|
params: serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100}),
|
|
visible: true,
|
|
}),
|
|
}
|
|
d.insert(Some(l), i, n).unwrap();
|
|
}
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_eq!(r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, before, "drawn again from the kept glyph geometry");
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
|
}
|
|
|
|
/// Type with a geometry effect in a symbol's art redraws in a font that becomes available: the art
|
|
/// kept for the instance is placed again when the fonts change.
|
|
#[test]
|
|
fn symbol_type_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
const FAMILY: &str = "Placed Serif 4";
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let style = CharStyle { size: 60.0, font_family: FAMILY.into(), ..Default::default() };
|
|
let mut t = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(-140.0, 25.0), "Hamburg", style))));
|
|
t.appearance.effects.push(vectorcraft_doc::Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true });
|
|
let art = Node::group(d.alloc_id(), vec![Arc::new(t)]);
|
|
d.symbols.push(vectorcraft_doc::Symbol { name: "Word".into(), art: Arc::new(art) });
|
|
let (l, id) = (d.layers[0].id, d.alloc_id());
|
|
d.insert(Some(l), 0, Node::new(id, NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 75.0)) })).unwrap();
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
|
}
|
|
|
|
/// Type that a geometry effect outlines redraws in a font that becomes available: the art drawn for
|
|
/// the effects of the type, of a group that holds it and of a symbol instance whose art holds it
|
|
/// is made again when the fonts change.
|
|
#[test]
|
|
fn type_with_geometry_effects_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
use vectorcraft_doc::Effect;
|
|
let moved = || Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true };
|
|
let cases = [
|
|
("Moving Serif 4", "the type with a Transform effect"),
|
|
("Shadow Serif 5", "the type with a Transform effect and a drop shadow"),
|
|
("Massed Serif 4", "the group with a Transform effect"),
|
|
("Stamps Serif 4", "the symbol instance with a Transform effect"),
|
|
("Darker Serif 4", "the type with a Transform effect in Multiply"),
|
|
];
|
|
for (i, (family, what)) in cases.into_iter().enumerate() {
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let style = CharStyle { size: 50.0, font_family: family.into(), ..Default::default() };
|
|
let at = if i == 3 { Point::new(-140.0, 20.0) } else { Point::new(10.0, 80.0) };
|
|
let mut object = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(at, "Hamburg", style))));
|
|
match i {
|
|
0 => object.appearance.effects.push(moved()),
|
|
1 => {
|
|
object.appearance.effects.push(moved());
|
|
let params = serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100});
|
|
object.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params, visible: true });
|
|
}
|
|
2 => {
|
|
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
|
object.appearance.effects.push(moved());
|
|
}
|
|
3 => {
|
|
let art = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
|
d.symbols.push(vectorcraft_doc::Symbol { name: "Word".into(), art: Arc::new(art) });
|
|
object = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 75.0)) });
|
|
object.appearance.effects.push(moved());
|
|
}
|
|
_ => {
|
|
object.appearance.effects.push(moved());
|
|
object.blend = vectorcraft_color::BlendMode::Multiply;
|
|
}
|
|
}
|
|
let l = d.layers[0].id;
|
|
d.insert(Some(l), 0, object).unwrap();
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(family)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "{what}: drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "{what}: as a new renderer draws it");
|
|
}
|
|
}
|
|
|
|
/// Type that an envelope bends redraws in a font that becomes available, in the envelope and in
|
|
/// the art of a symbol whose instance an envelope bends: the envelopes are evaluated again when the
|
|
/// fonts change.
|
|
#[test]
|
|
fn enveloped_type_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
const FAMILY: &str = "Warped Serif 4";
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let word = |d: &mut Document, at: Point| {
|
|
let style = CharStyle { size: 50.0, font_family: FAMILY.into(), ..Default::default() };
|
|
Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(at, "Hamburg", style))))
|
|
};
|
|
let typed = word(&mut d, Point::new(10.0, 60.0));
|
|
let art = word(&mut d, Point::new(-140.0, 20.0));
|
|
let art = Node::group(d.alloc_id(), vec![Arc::new(art)]);
|
|
d.symbols.push(vectorcraft_doc::Symbol { name: "Word".into(), art: Arc::new(art) });
|
|
let shown = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 120.0)) });
|
|
let l = d.layers[0].id;
|
|
for (i, content) in [typed, shown].into_iter().enumerate() {
|
|
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true };
|
|
let envelope = NodeKind::Envelope {
|
|
content: vec![Arc::new(content)],
|
|
kind: Box::new(kind),
|
|
fidelity: 50.0,
|
|
editing: false,
|
|
options: Default::default(),
|
|
frame: Box::new(Affine::IDENTITY),
|
|
};
|
|
let id = d.alloc_id();
|
|
d.insert(Some(l), i, Node::new(id, envelope)).unwrap();
|
|
}
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
|
}
|
|
|
|
/// Type that an envelope bends redraws in a font that becomes available when the art drawn for
|
|
/// effects is made from the envelope's evaluation: the envelope with a drop shadow, and the
|
|
/// envelope in a group with a geometry effect or with a fill of its own.
|
|
#[test]
|
|
fn enveloped_type_under_effects_redraws_when_its_font_becomes_available() {
|
|
let _adding = adding_fonts();
|
|
use vectorcraft_color::{Color, Paint};
|
|
use vectorcraft_doc::{AppearanceItem, Effect, FillLayer};
|
|
let cases = [
|
|
("Shadow Serif 4", "the envelope with a drop shadow"),
|
|
("Effect Serif 4", "the group with a geometry effect"),
|
|
("Filled Serif 4", "the group with a fill"),
|
|
];
|
|
for (i, (family, what)) in cases.into_iter().enumerate() {
|
|
let mut d = Document::new(300.0, 150.0);
|
|
let style = CharStyle { size: 50.0, font_family: family.into(), ..Default::default() };
|
|
let typed = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 80.0), "Hamburg", style))));
|
|
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true };
|
|
let envelope = NodeKind::Envelope {
|
|
content: vec![Arc::new(typed)],
|
|
kind: Box::new(kind),
|
|
fidelity: 50.0,
|
|
editing: false,
|
|
options: Default::default(),
|
|
frame: Box::new(Affine::IDENTITY),
|
|
};
|
|
let mut object = Node::new(d.alloc_id(), envelope);
|
|
match i {
|
|
0 => {
|
|
let params = serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100});
|
|
object.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params, visible: true });
|
|
}
|
|
1 => {
|
|
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
|
object.appearance.effects.push(Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true });
|
|
}
|
|
_ => {
|
|
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
|
object.appearance.items.push(AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)))));
|
|
}
|
|
}
|
|
let l = d.layers[0].id;
|
|
d.insert(Some(l), 0, object).unwrap();
|
|
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
|
let mut r = Renderer::new();
|
|
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(family)) > 0);
|
|
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
|
assert_ne!(before, after, "{what}: drawn in the font that arrived");
|
|
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "{what}: as a new renderer draws it");
|
|
}
|
|
}
|