Files
AniCraft/crates/render/src/html_tests.rs
T

1418 lines
87 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use super::*;
use anicraft_doc::actions::{ButtonEvent, EventHandler, PluginScript, Property, Target};
use anicraft_doc::player::{Event, NoScripts, PlayerState, start, step};
use anicraft_doc::{BlendMode, ColorEffect, ColorTransform, ElementId, GradientStop, Keyframe, LayerId, LoopMode, Scene, Shape, Symbol, Tween, evaluate_player, sample};
use anicraft_geom::Vec2;
use boa_engine::{Context, Source};
// ----- fixtures ---------------------------------------------------------------------------------
fn rect(id: u64, x: f32, y: f32, w: f32, h: f32, c: u32) -> Arc<Element> {
Arc::new(Element { id: ElementId(id), name: String::new(), transform: Affine::IDENTITY, color: ColorEffect::default(), kind: ElementKind::Shape(Shape::filled(Path::rect(x, y, w, h), Paint::Solid(Rgba::hex(c)))) })
}
fn inst(id: u64, symbol: u64, name: &str, m: Affine, events: Vec<EventHandler>) -> Arc<Element> {
Arc::new(Element { id: ElementId(id), name: name.into(), transform: m, color: ColorEffect::default(), kind: ElementKind::Symbol { symbol: SymbolId(symbol), loop_mode: LoopMode::Loop, first_frame: 0, blend: BlendMode::Normal, filters: Vec::new(), events } })
}
fn kf(start: u32, duration: u32, elements: Vec<Arc<Element>>, actions: Vec<Action>, label: &str) -> Arc<Keyframe> {
let mut k = Keyframe::new(start, duration);
k.elements = elements;
k.label = label.into();
k.script = (!actions.is_empty()).then_some(FrameScript::Actions(actions));
Arc::new(k)
}
fn tweened(k: Arc<Keyframe>) -> Arc<Keyframe> {
let mut k = (*k).clone();
k.tween = Some(Tween::default());
Arc::new(k)
}
fn layer(id: u64, keys: Vec<Arc<Keyframe>>) -> Arc<Layer> {
let mut l = Layer::new(LayerId(id), format!("L{id}"));
l.keyframes = keys;
Arc::new(l)
}
fn symbol(id: u64, kind: SymbolKind, layers: Vec<Arc<Layer>>) -> Arc<Symbol> {
Arc::new(Symbol { id: SymbolId(id), name: format!("S{id}"), kind, linkage: None, scale_grid_kept: None, scale_grid: None, timeline: Timeline { layers } })
}
fn this() -> Target {
Target::this()
}
fn on(event: ButtonEvent, actions: Vec<Action>) -> EventHandler {
EventHandler { event, actions }
}
/// A self-authored interactive movie that exercises the player: a door movie clip with labels
/// and stops, a tweened slide inside it, a button with all four states that opens the door and
/// fades it on hover, a nested clip addressed by a dotted path, a looping graphic under a mask,
/// a faded group, a gradient, a target that doesn't exist, and a second scene that goes back.
fn fixture() -> Document {
let mut d = Document { stage: anicraft_doc::Stage { width: 640, height: 360, fps: 24.0, background: Rgba::hex(0x223344) }, ..Document::default() };
// The door: closed (stop), opening (a slide), open (stop, trace).
let slide_a = rect(1001, 0.0, 0.0, 80.0, 120.0, 0x8b5a2b);
let mut slide_b = (*slide_a).clone();
slide_b.transform = Affine::translate(60.0, 0.0);
let door = symbol(100, SymbolKind::MovieClip, vec![
layer(101, vec![kf(0, 1, vec![], vec![Action::Stop { target: this() }], "closed"), kf(1, 4, vec![], vec![], "opening"), kf(5, 1, vec![], vec![Action::Stop { target: this() }, Action::Trace { message: "door open".into() }], "open")]),
layer(102, vec![kf(0, 1, vec![slide_a.clone()], vec![], ""), tweened(kf(1, 4, vec![slide_a], vec![], "")), kf(5, 1, vec![Arc::new(slide_b)], vec![], "")]),
]);
// The knob: Up, Over, Down, Hit.
let knob = symbol(200, SymbolKind::Button, vec![layer(201, vec![kf(0, 1, vec![rect(2001, -20.0, -20.0, 40.0, 40.0, 0x3d8bfd)], vec![], ""), kf(1, 1, vec![rect(2002, -20.0, -20.0, 40.0, 40.0, 0x6aa8ff)], vec![], ""), kf(2, 1, vec![rect(2003, -20.0, -20.0, 40.0, 40.0, 0x2a64c0)], vec![], ""), kf(3, 1, vec![rect(2004, -25.0, -25.0, 50.0, 50.0, 0)], vec![], "")])]);
// A looping three-frame graphic.
let mut red = (*rect(3001, 0.0, 0.0, 30.0, 30.0, 0xff0000)).clone();
red.color = ColorEffect::Brightness(0.2).with_alpha(0.8);
let blink = symbol(300, SymbolKind::Graphic, vec![layer(301, vec![kf(0, 1, vec![Arc::new(red)], vec![], ""), kf(1, 1, vec![rect(3002, 0.0, 0.0, 30.0, 30.0, 0x00ff00)], vec![], ""), kf(2, 1, vec![rect(3003, 0.0, 0.0, 30.0, 30.0, 0x0000ff)], vec![], "")])]);
// A panel clip holding its own door (panel.door), that plays on and talks to its parent.
let panel = symbol(400, SymbolKind::MovieClip, vec![
layer(401, vec![kf(0, 2, vec![], vec![], ""), kf(2, 2, vec![], vec![Action::Trace { message: "panel frame 3".into() }, Action::SetProperty { target: Target::new("parent.door"), property: Property::X, value: 250.0 }], "")]),
layer(402, vec![kf(0, 4, vec![inst(4001, 100, "door", Affine::translate(10.0, 10.0), vec![])], vec![], "")]),
]);
d.library = vec![door, knob, blink, panel];
let open_door = vec![Action::GotoAndPlay { target: Target::new("door"), frame: FrameRef::Label("opening".into()), scene: None }, Action::Play { target: Target::new("panel.door") }];
let knob_events = vec![
on(ButtonEvent::Click, open_door),
on(ButtonEvent::Over, vec![Action::SetProperty { target: Target::new("door"), property: Property::Alpha, value: 0.5 }]),
on(ButtonEvent::Out, vec![Action::SetProperty { target: Target::new("door"), property: Property::Alpha, value: 1.0 }]),
on(ButtonEvent::Press, vec![Action::Trace { message: "pressed".into() }]),
on(ButtonEvent::Release, vec![Action::GotoAndStop { target: Target::new("panel"), frame: FrameRef::Number(99), scene: None }]),
];
let mut faded = (*inst(5003, 300, "", Affine::translate(500.0, 40.0), vec![])).clone();
// Advanced, with an alpha offset (it stays on each item: no group fade).
faded.color = ColorEffect::Advanced(ColorTransform { mul: [0.4, 0.4, 0.4, 0.5], add: [0.0, 0.6, 0.6, 0.1] });
let gradient = Arc::new(Element {
id: ElementId(5004),
name: String::new(),
transform: Affine::translate(20.0, 300.0),
color: ColorEffect::Tint { color: Rgba::hex(0xff00ff), amount: 0.25 },
kind: ElementKind::Shape(Shape::filled(Path::rect(0.0, 0.0, 100.0, 40.0), Paint::linear(Vec2::new(0.0, 0.0), Vec2::new(100.0, 0.0), vec![GradientStop { offset: 0.0, color: Rgba::hex(0xffffff) }, GradientStop { offset: 1.0, color: Rgba::hex(0x000000) }])).with_stroke(Rgba::hex(0xffff00), 2.0)),
});
let mut mask = Layer::new(LayerId(6), "mask");
mask.kind = LayerKind::Mask;
// A soft mask (ADR 0070): the player numbers its clip's mode as the evaluator does.
mask.mask_mode = anicraft_doc::MaskMode::Luminance;
mask.keyframes = vec![kf(0, 30, vec![rect(5005, 400.0, 0.0, 20.0, 100.0, 0)], vec![], "")];
let mut masked = Layer::new(LayerId(7), "masked");
masked.parent = Some(LayerId(6));
masked.keyframes = vec![kf(0, 30, vec![inst(5006, 300, "", Affine::translate(395.0, 30.0), vec![])], vec![], "")];
d.timeline_mut(0).layers = vec![
layer(1, vec![
kf(0, 3, vec![], vec![Action::Trace { message: "start".into() }], ""),
kf(3, 7, vec![], vec![Action::Stop { target: Target::new("ghost") }, Action::Stop { target: Target::new("panel") }], "mid"),
kf(10, 20, vec![], vec![], ""),
kf(29, 1, vec![], vec![Action::GotoAndPlay { target: this(), frame: FrameRef::Label("back".into()), scene: None }], ""),
]),
layer(2, vec![kf(0, 30, vec![inst(5001, 200, "knob", Affine::translate(100.0, 100.0), knob_events)], vec![], "")]),
layer(3, vec![kf(0, 30, vec![inst(5002, 100, "door", Affine::translate(300.0, 100.0), vec![]), inst(5007, 400, "panel", Affine::translate(300.0, 240.0), vec![]), Arc::new(faded), gradient], vec![], "")]),
Arc::new(mask),
Arc::new(masked),
];
// Scene 2 has the "back" label and returns to the first scene's "mid".
let mut two = Scene::new("Two");
two.timeline.layers = vec![layer(8, vec![kf(0, 2, vec![rect(6001, 0.0, 0.0, 640.0, 360.0, 0x112233)], vec![], "back"), kf(2, 1, vec![], vec![Action::GotoAndStop { target: this(), frame: FrameRef::Label("mid".into()), scene: Some("scene 1".into()) }], "")])];
d.scenes.push(Arc::new(two));
d.next_id = 10_000;
d.sanitize();
d
}
// ----- the JavaScript player in Boa --------------------------------------------------------------
/// Hit tests for the JS player, over the exported paths flattened in Rust (what `Path::contains`
/// and `distance_to_edge` test), in place of the browser's canvas.
const HOST_JS: &str = r#"
function xf(m, q) { return [m[0] * q[0] + m[2] * q[1] + m[4], m[1] * q[0] + m[3] * q[1] + m[5]]; }
var host = {
inFill: function (p, m, x, y, eo) {
var wind = 0, cross = 0;
for (var line of (POLYS[p] || [])) {
var pts = line.p.map(function (q) { return xf(m, q); });
for (var i = 0; i < pts.length; i++) {
var a = pts[i], b = pts[(i + 1) % pts.length];
if ((a[1] <= y) !== (b[1] <= y)) {
var t = (y - a[1]) / (b[1] - a[1]);
if (a[0] + t * (b[0] - a[0]) > x) { cross++; wind += b[1] > a[1] ? 1 : -1; }
}
}
}
return eo ? cross % 2 === 1 : wind !== 0;
},
nearStroke: function (p, m, x, y, reach) {
for (var line of (POLYS[p] || [])) {
var pts = line.p.map(function (q) { return xf(m, q); });
var n = line.c ? pts.length : pts.length - 1;
for (var i = 0; i < n; i++) {
var a = pts[i], b = pts[(i + 1) % pts.length];
var dx = b[0] - a[0], dy = b[1] - a[1], l = dx * dx + dy * dy;
var t = l > 0 ? Math.max(0, Math.min(1, ((x - a[0]) * dx + (y - a[1]) * dy) / l)) : 0;
var ex = a[0] + t * dx - x, ey = a[1] + t * dy - y;
if (Math.sqrt(ex * ex + ey * ey) <= reach) return true;
}
}
return false;
}
};
"#;
struct Js {
ctx: Context,
}
impl Js {
fn new(m: &Movie) -> Js {
let mut ctx = Context::default();
ctx.eval(Source::from_bytes(PLAYER_JS)).unwrap_or_else(|e| panic!("player.js: {e}"));
ctx.eval(Source::from_bytes(FILTERS_JS)).unwrap_or_else(|e| panic!("filters.js: {e}"));
ctx.eval(Source::from_bytes(HOST_JS)).unwrap();
let polys: Vec<Value> = m.paths.iter().map(|p| Value::Array(p.flatten(&Affine::IDENTITY, 0.05).into_iter().map(|l| json!({"c": l.closed, "p": l.points.iter().map(|q| json!([q.x, q.y])).collect::<Vec<_>>()})).collect())).collect();
let setup = format!("var POLYS = {}; var P = new AniCraft.Player({}, host);", Value::Array(polys), m.json);
ctx.eval(Source::from_bytes(&setup)).unwrap_or_else(|e| panic!("setup: {e}"));
Js { ctx }
}
fn eval(&mut self, code: &str) -> Value {
let v = self.ctx.eval(Source::from_bytes(&format!("JSON.stringify({code})"))).unwrap_or_else(|e| panic!("{code}: {e}"));
let s = v.to_string(&mut self.ctx).unwrap().to_std_string_escaped();
serde_json::from_str(&s).unwrap_or_else(|e| panic!("{code}: {e}: {s}"))
}
}
fn js_events(events: &[Event]) -> String {
let list: Vec<Value> = events
.iter()
.map(|e| match e {
Event::Move(p) => json!({"type": "move", "x": p.x, "y": p.y}),
Event::Down(p) => json!({"type": "down", "x": p.x, "y": p.y}),
Event::Up(p) => json!({"type": "up", "x": p.x, "y": p.y}),
Event::Leave => json!({"type": "leave"}),
Event::KeyDown(k) => json!({"type": "keydown", "code": k}),
Event::KeyUp(k) => json!({"type": "keyup", "code": k}),
Event::Char(c) => json!({"type": "char", "text": c.to_string()}),
Event::SelectAll => json!({"type": "selectall"}),
})
.collect();
Value::Array(list).to_string()
}
fn ids(p: &[ElementId]) -> Value {
Value::Array(p.iter().map(|e| json!(e.0)).collect())
}
/// The Rust state in the shape of the JS player's `snapshot()` (props compared apart).
fn snapshot(st: &PlayerState) -> Value {
json!({
"scene": st.scene, "frame": st.root.frame, "playing": st.root.playing,
"clips": st.clips.iter().map(|(p, c)| json!([ids(p), c.frame, c.playing])).collect::<Vec<_>>(),
"listeners": st.listeners.iter().filter(|(_, l)| !l.is_empty()).map(|(p, l)| json!([ids(p), l.iter().map(|x| json!([x.event.key(), ids(&x.owner), x.function])).collect::<Vec<_>>()])).collect::<Vec<_>>(),
"stage": st.stage.iter().map(|x| json!([x.event.key(), ids(&x.owner), x.function])).collect::<Vec<_>>(),
"vars": st.vars.iter().map(|(p, v)| json!([ids(p), v.iter().map(|(k, v)| json!([k, format!("{}:{}", kind(v), v.text())])).collect::<Vec<_>>()])).collect::<Vec<_>>(),
"hover": st.hover.as_deref().map(ids), "pressed": st.pressed.as_deref().map(ids), "down": st.down,
"fields": st.fields.iter().map(|(p, f)| json!([ids(p), f.text, f.caret, f.anchor])).collect::<Vec<_>>(),
"focus": st.focus.as_deref().map(ids), "selecting": st.selecting, "shift": st.shift,
})
}
/// A script value's kind, as the JS snapshot tags it.
fn kind(v: &anicraft_doc::actions::as3::ir::Value) -> &'static str {
use anicraft_doc::actions::as3::ir::Value as V;
match v {
V::Undefined => "u",
V::Null => "null",
V::Bool(_) => "b",
V::Num(_) => "n",
V::Str(_) => "s",
}
}
fn props_of_rust(st: &PlayerState) -> Vec<String> {
let mut out = Vec::new();
for (p, o) in &st.props {
let f = |k: &str, v: Option<f32>| v.map(|v| format!("{}:{k}={:.3}", ids(p), v));
out.extend([f("x", o.x), f("y", o.y), f("alpha", o.alpha), f("rotation", o.rotation), f("scale_x", o.scale_x), f("scale_y", o.scale_y)].into_iter().flatten());
if let Some(v) = o.visible {
out.push(format!("{}:visible={v}", ids(p)));
}
}
out.sort();
out
}
fn props_of_js(snap: &Value) -> Vec<String> {
let mut out = Vec::new();
for e in snap["props"].as_array().unwrap() {
let path = &e[0];
for (k, v) in e[1].as_object().unwrap() {
out.push(match v {
Value::Bool(b) => format!("{path}:{k}={b}"),
v => format!("{path}:{k}={:.3}", v.as_f64().unwrap()),
});
}
}
out.sort();
out
}
fn close(a: f64, b: f32, tol: f64) -> bool {
(a - f64::from(b)).abs() <= tol
}
/// The JS player's display list against `evaluate_player` at the same state: the same items in
/// the same order, with the same paths, placement, paints, colour effects, clips and groups.
fn same_display_list(js: &mut Js, m: &Movie, doc: &Document, st: &PlayerState, when: &str) {
let dl = evaluate_player(doc, st);
let ours = js.eval("P.evaluate()");
let items: Vec<&anicraft_doc::DisplayItem> = dl.items.iter().filter(|i| !i.guide).collect();
let theirs = ours["items"].as_array().unwrap();
assert_eq!(theirs.len(), items.len(), "{when}: item count");
for (k, (a, b)) in theirs.iter().zip(&items).enumerate() {
let p = a["p"].as_u64().unwrap() as usize;
assert_eq!(*m.paths[p], *b.path, "{when}: item {k} path");
let mj: Vec<f64> = a["m"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
for (i, (x, y)) in mj.iter().zip(b.transform.m).enumerate() {
assert!(close(*x, y, if i < 4 { 1e-3 } else { 1e-2 }), "{when}: item {k} transform {mj:?} vs {:?}", b.transform.m);
}
let fill = a["f"].as_i64().unwrap();
assert_eq!(fill >= 0, b.fill.is_some(), "{when}: item {k} fill");
if let (Some(Paint::Solid(c)), true) = (&b.fill, fill >= 0) {
let s = &m.json["paints"][fill as usize]["s"];
for (x, y) in s.as_array().unwrap().iter().zip([c.r, c.g, c.b, c.a]) {
assert!(close(x.as_f64().unwrap(), y, 1e-3), "{when}: item {k} colour");
}
}
assert_eq!(a["s"].is_array(), b.stroke.is_some(), "{when}: item {k} stroke");
let c = &a["c"];
for (i, y) in b.color.mul.into_iter().chain(b.color.add).enumerate() {
assert!(close(c[i].as_f64().unwrap(), y, 1e-3), "{when}: item {k} colour effect {c} vs {:?}", b.color);
}
let idx = |v: &Value| v.as_u64().map(|x| x as u32);
assert_eq!((idx(&a["clip"]), idx(&a["masks"]), idx(&a["group"])), (b.clip, b.masks, b.group), "{when}: item {k} clip, mask and group");
}
let clips: Vec<Option<u32>> = ours["clips"].as_array().unwrap().iter().map(|v| v.as_u64().map(|x| x as u32)).collect();
assert_eq!(clips, dl.clip_parents, "{when}: clips");
let modes = ours["modes"].as_array().unwrap();
for c in 0..dl.clip_parents.len() {
let want = match dl.clip_mode(c as u32) {
anicraft_doc::MaskMode::Coverage => 0,
anicraft_doc::MaskMode::Alpha => 1,
anicraft_doc::MaskMode::Luminance => 2,
};
assert_eq!(modes.get(c).and_then(Value::as_u64).unwrap_or(0), want, "{when}: clip {c} mode");
}
let groups = ours["groups"].as_array().unwrap();
assert_eq!(groups.len(), dl.groups.len(), "{when}: groups");
for (a, b) in groups.iter().zip(&dl.groups) {
assert!(close(a["alpha"].as_f64().unwrap(), b.alpha, 1e-3), "{when}: group alpha");
assert_eq!(a["blend"], b.blend.key(), "{when}: group blend");
assert_eq!(a["filters"].as_array().map_or(0, Vec::len), b.filters.len(), "{when}: group filters");
assert_eq!((a["parent"].as_u64().map(|x| x as u32), a["clip"].as_u64().map(|x| x as u32)), (b.parent, b.clip), "{when}: group nesting");
}
}
/// Runs `doc` in both players through `script` (per step: events after the frame, and pointer
/// events routed between frames), comparing state, output and display list at every step.
fn compare(doc: &Document, script: &[(Vec<Event>, Vec<Event>)]) -> Vec<String> {
let m = movie(doc, &HtmlOptions::default());
let mut js = Js::new(&m);
let r = start(doc, &mut NoScripts);
let out = js.eval("P.start().output");
assert_eq!(out, json!(r.output), "start: output");
let mut lines = r.output.clone();
let mut st = r.state;
for (i, (between, after)) in script.iter().enumerate() {
let when = format!("step {}", i + 1);
if !between.is_empty() {
let r = anicraft_doc::player::input(doc, &st, between, &mut NoScripts);
assert_eq!(js.eval(&format!("P.input({}).output", js_events(between))), json!(r.output), "{when}: input output");
lines.extend(r.output.iter().cloned());
st = r.state;
}
let r = step(doc, &st, after, &mut NoScripts);
assert_eq!(js.eval(&format!("P.step({}).output", js_events(after))), json!(r.output), "{when}: output");
lines.extend(r.output.iter().cloned());
st = r.state;
let snap = js.eval("P.snapshot()");
let mut lean = snap.clone();
lean.as_object_mut().unwrap().remove("props");
assert_eq!(lean, snapshot(&st), "{when}: state");
assert_eq!(props_of_js(&snap), props_of_rust(&st), "{when}: properties");
same_display_list(&mut js, &m, doc, &st, &when);
}
lines
}
fn at(x: f32, y: f32) -> Vec2 {
Vec2::new(x, y)
}
// ----- the tests --------------------------------------------------------------------------------
#[test]
fn the_js_player_plays_the_fixture_frame_for_frame_like_the_rust_player() {
let doc = fixture();
let none = || (vec![], vec![]);
let mut script: Vec<(Vec<Event>, Vec<Event>)> = (0..2).map(|_| none()).collect();
// Hover the knob between frames (Over: the door fades), press and release on it (a click
// opens both doors), wander off (Out), then click again while it is open.
script.push((vec![Event::Move(at(100.0, 100.0))], vec![]));
script.push((vec![Event::Down(at(101.0, 99.0))], vec![]));
script.push((vec![], vec![Event::Up(at(102.0, 101.0))]));
script.extend((0..6).map(|_| none()));
script.push((vec![Event::Move(at(10.0, 10.0))], vec![]));
script.push((vec![], vec![Event::Down(at(122.0, 122.0)), Event::Up(at(122.0, 122.0))]));
script.push((vec![Event::Move(at(124.0, 76.0)), Event::Leave], vec![]));
// On through the end of scene 1, scene 2 and back.
script.extend((0..30).map(|_| none()));
let lines = compare(&doc, &script);
for want in ["start", "pressed", "door open", "panel frame 3", "Stop (ghost): no instance named “ghost” here"] {
assert!(lines.iter().any(|l| l == want), "the fixture never wrote {want:?}: {lines:?}");
}
}
#[test]
fn the_js_player_plays_the_interactive_sample_like_the_rust_player() {
let doc = sample::interactive();
let mut script: Vec<(Vec<Event>, Vec<Event>)> = vec![(vec![], vec![]); 3];
script.push((vec![Event::Move(at(640.0, 400.0))], vec![]));
script.push((vec![Event::Down(at(640.0, 400.0))], vec![Event::Up(at(640.0, 400.0))]));
script.extend(vec![(vec![], vec![]); 40]);
assert!(compare(&doc, &script).iter().any(|l| l == "The show starts"), "the Play button starts the show");
}
#[test]
fn the_js_player_matches_on_the_demo_and_on_go_to_loops() {
// No actions: the movie loops; every movie clip and graphic follows.
let demo = sample::demo();
compare(&demo, &vec![(vec![], vec![]); 60]);
// A frame that goes to itself and back runs into the budget, in both players alike.
let mut d = Document::default();
d.timeline_mut(0).layers = vec![layer(1, vec![
kf(0, 1, vec![], vec![Action::GotoAndPlay { target: this(), frame: FrameRef::Number(1), scene: None }], ""),
kf(1, 1, vec![], vec![Action::GotoAndPlay { target: this(), frame: FrameRef::Number(0), scene: None }, Action::SetProperty { target: this(), property: Property::X, value: 1.0 }, Action::NextFrame { target: Target::new("_root.nobody") }], ""),
])];
d.sanitize();
compare(&d, &vec![(vec![], vec![]); 3]);
}
#[test]
fn the_camera_and_layer_depth_come_across_and_buttons_answer_through_them() {
// The fixture through a camera that pans, zooms, turns and tints over frames 1-20, with a
// layer behind the stage (parallax): the knob is clicked where the camera shows it.
let mut doc = fixture();
let stage = doc.stage;
let mut far = anicraft_doc::Camera::rest(&stage);
far.center = Vec2::new(260.0, 150.0);
far.zoom = 1.5;
far.rotation = 0.2;
far.tint = Rgba::hex(0x3366ff);
far.tint_amount = 0.3;
let rest = anicraft_doc::Camera::rest(&stage).to_element(ElementId(7001));
let near = far.to_element(ElementId(7001));
let mut cam = Layer::new(LayerId(70), "Camera");
cam.kind = LayerKind::Camera;
cam.keyframes = vec![tweened(kf(0, 20, vec![Arc::new(rest)], vec![], "")), kf(20, 10, vec![Arc::new(near)], vec![], "")];
let tl = doc.timeline_mut(0);
tl.layers.insert(0, Arc::new(cam));
Arc::make_mut(&mut tl.layers[3]).depth = 200.0;
doc.sanitize();
let m = movie(&doc, &HtmlOptions::default());
let first = &m.json["timelines"][0];
assert!(m.json["contents"].as_array().unwrap().iter().any(|c| c["cc"].is_array()), "the camera's tint is baked");
assert!(first["f"].as_array().unwrap().len() > 15, "the camera moves every frame");
// Where the knob is on screen once the camera has arrived.
let knob = far.view(&stage, 0.0).apply(Vec2::new(100.0, 100.0));
let mut script: Vec<(Vec<Event>, Vec<Event>)> = vec![(vec![], vec![]); 22];
script.push((vec![Event::Move(knob), Event::Down(knob)], vec![Event::Up(knob)]));
script.extend(vec![(vec![], vec![]); 6]);
let lines = compare(&doc, &script);
assert!(lines.iter().any(|l| l == "door open"), "the click reached the knob through the camera: {lines:?}");
}
#[test]
fn the_page_holds_the_movie_and_the_player_and_nothing_can_close_its_scripts() {
let doc = fixture();
let e = to_html(&doc, &HtmlOptions { title: "Doors </script> & \"knobs\"".into(), ..Default::default() }).unwrap();
assert!(e.html.starts_with("<!DOCTYPE html>"));
assert!(e.html.contains("<title>Doors &lt;/script&gt; &amp; &quot;knobs&quot;</title>"));
for js in [PLAYER_JS, FILTERS_JS, CANVAS_JS] {
assert!(!js.to_ascii_lowercase().contains("</script") && !js.contains("<!--"), "a script source would end its element");
}
// Exactly the three scripts' closing tags, and the data reads back as the movie.
assert_eq!(e.html.matches("</script>").count(), 2);
let start = e.html.find("id=\"anicraft-movie\">").unwrap() + "id=\"anicraft-movie\">".len();
let end = start + e.html[start..].find("</script>").unwrap();
let back: Value = serde_json::from_str(&e.html[start..end]).unwrap();
assert_eq!(back, movie(&doc, &HtmlOptions::default()).json);
assert_eq!(back["v"], FORMAT_VERSION);
assert_eq!(back["scenes"].as_array().unwrap().len(), 2);
assert_eq!((back["stage"]["w"].as_u64(), back["stage"]["fps"].as_f64()), (Some(640), Some(24.0)));
assert_eq!(e.stats.data_bytes, end - start);
assert!(e.report.is_empty(), "nothing lost: {:?}", e.report);
// The page's script holds the player, the filters and the page code, in that order (the page
// code uses both).
let script = &e.html[end..];
let at = |js: &str| script.find(js).unwrap_or_else(|| panic!("a script is missing from the page"));
assert!(at(PLAYER_JS) < at(FILTERS_JS) && at(FILTERS_JS) < at(CANVAS_JS));
// The page code needs a browser to run, but it must compile.
let mut ctx = Context::default();
ctx.eval(Source::from_bytes(&format!("new Function({})", json!(CANVAS_JS)))).unwrap_or_else(|e| panic!("canvas.js: {e}"));
}
#[test]
fn frames_are_baked_and_stored_once() {
let doc = sample::demo();
let m = movie(&doc, &HtmlOptions::default());
let frames = doc.frame_count() as usize;
assert_eq!(m.json["timelines"][0]["n"].as_u64(), Some(frames as u64));
assert!(m.stats.frames >= frames && m.stats.contents <= m.stats.frames, "{:?}", m.stats);
// A keyframe held over many frames is one stored frame.
let mut still = Document::default();
{
let l = Arc::make_mut(&mut still.timeline_mut(0).layers[0]);
l.keyframes = vec![kf(0, 50, vec![rect(9, 0.0, 0.0, 10.0, 10.0, 0xff0000)], vec![], "")];
}
let s = movie(&still, &HtmlOptions::default());
assert_eq!((s.stats.frames, s.stats.contents, s.json["timelines"][0]["f"].clone()), (50, 1, json!([[0, 50]])));
// Runs add up to each timeline's length.
for tl in m.json["timelines"].as_array().unwrap() {
let total: u64 = tl["f"].as_array().unwrap().iter().map(|r| r[1].as_u64().unwrap()).sum();
assert_eq!(Some(total), tl["n"].as_u64());
}
// A still shape over many frames is one path; a tween moves its transform, not its path.
assert!(m.stats.paths < 40, "{:?}", m.stats);
// Unused library symbols stay out.
let mut d = doc.clone();
d.library.push(Arc::new(Symbol { id: SymbolId(999_999), name: "unused".into(), kind: SymbolKind::Graphic, linkage: None, scale_grid_kept: None, scale_grid: None, timeline: Timeline::default() }));
assert_eq!(movie(&d, &HtmlOptions::default()).json["symbols"], m.json["symbols"]);
}
#[test]
fn variable_width_strokes_become_filled_outlines() {
use anicraft_doc::{ProfilePreset, Stroke};
let mut doc = Document::default();
let shape = Shape { path: Arc::new(Path::line(Vec2::new(10.0, 10.0), Vec2::new(200.0, 10.0))), fill: None, stroke: Some(Stroke::new(Rgba::hex(0x00ff00), 10.0).with_profile(ProfilePreset::TaperEnd.profile())), fill_rule: FillRule::NonZero, merge: false, warp: None };
let el = Element { id: ElementId(77), name: String::new(), transform: Affine::translate(5.0, 0.0), color: Default::default(), kind: ElementKind::Shape(shape) };
Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap().elements.push(Arc::new(el));
let m = movie(&doc, &HtmlOptions::default());
let items = &m.json["contents"][0]["l"][0]["e"];
assert_eq!(items.as_array().unwrap().len(), 1);
assert!(items[0]["f"].is_u64() && items[0]["s"].is_null(), "{items}");
assert!(items[0]["m"].is_null(), "the outline is already in place");
}
#[test]
fn stroke_caps_joins_and_dashes_reach_the_page() {
use anicraft_doc::{Cap, Dash, Join, Stroke, StrokeStyle};
let mut doc = Document::default();
let style = StrokeStyle { cap: Cap::Butt, join: Join::Miter, miter_limit: 6.0, dash: Some(Dash::Dashed { lengths: vec![4.0, 1.5].into(), offset: 1.0 }) };
let line = |y: f32, st: Stroke| Shape { path: Arc::new(Path::line(Vec2::new(10.0, y), Vec2::new(200.0, y))), fill: None, stroke: Some(st), fill_rule: FillRule::NonZero, merge: false, warp: None };
let shapes = [line(10.0, Stroke::new(Rgba::BLACK, 3.0)), line(30.0, Stroke::new(Rgba::BLACK, 3.0).with_style(style)), line(50.0, Stroke::new(Rgba::BLACK, 3.0).with_style(StrokeStyle { dash: Dash::dotted(2.0), ..StrokeStyle::default() }))];
for (i, sh) in shapes.into_iter().enumerate() {
let el = Element { id: ElementId(70 + i as u64), name: String::new(), transform: Affine::scale(2.0, 2.0), color: Default::default(), kind: ElementKind::Shape(sh) };
Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap().elements.push(Arc::new(el));
}
let m = movie(&doc, &HtmlOptions::default());
let items = &m.json["contents"][0]["l"][0]["e"];
// Round and solid: no style entry, as before.
assert!(items[0]["s"].is_array() && items[0].get("k").is_none(), "{items}");
// Lengths stay in local units; the page scales them like the width.
assert_eq!(items[1]["k"], json!({"c": "butt", "j": "miter", "ml": 6, "d": [4, 1.5], "o": 1}));
assert_eq!(items[2]["k"], json!({"c": "round", "j": "round", "ml": 3, "d": [0, 5], "o": 0}), "dots are round zero-length dashes");
// The player hands the style to the page with each item.
let mut js = Js::new(&m);
js.eval("P.start()");
let ours = js.eval("P.evaluate()");
let theirs = ours["items"].as_array().unwrap();
assert!(theirs[0]["k"].is_null());
assert_eq!(theirs[1]["k"], items[1]["k"]);
}
#[test]
fn what_does_not_carry_across_is_reported() {
let mut doc = fixture();
let tl = doc.timeline_mut(0);
let l = Arc::make_mut(&mut tl.layers[2]);
let k = l.keyframe_mut(0).unwrap();
if let ElementKind::Symbol { filters, blend, .. } = &mut Arc::make_mut(&mut k.elements[0]).kind {
filters.push(anicraft_doc::Filter::Blur { blur_x: 4.0, blur_y: 4.0, quality: 1 });
*blend = BlendMode::Subtract;
}
Arc::make_mut(&mut tl.layers[0]).keyframe_mut(1).unwrap().script = Some(FrameScript::Plugin(PluginScript { id: "org.example.menu".into(), entry: "main".into() }));
// A 9-slice symbol, scaled: the page scales it as a whole (ADR 0055).
let ElementKind::Symbol { symbol: sym, .. } = doc.timeline(0).layers[2].keyframes[0].elements[0].kind else { panic!("the fixture's third layer holds an instance") };
if let Some(x) = doc.library.iter_mut().find(|x| x.id == sym) {
Arc::make_mut(x).scale_grid = Some(anicraft_doc::ScaleGrid { left: 1.0, right: 2.0, top: 1.0, bottom: 2.0 });
}
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.report.get(NINE_SLICE), None, "unscaled instances draw the same either way");
let tl = doc.timeline_mut(0);
Arc::make_mut(&mut Arc::make_mut(&mut tl.layers[2]).keyframe_mut(0).unwrap().elements[0]).transform = Affine::scale(2.0, 1.0);
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.report.get(NINE_SLICE), Some(&1));
// Filters and Subtract run in the page (ADR 0072): not reported, and exported.
assert!(!m.report.keys().any(|k| k.contains("filter") || k.contains("Subtract")), "{:?}", m.report);
let el = &m.json["contents"].as_array().unwrap().iter().flat_map(|c| c["l"].as_array().unwrap().iter().flat_map(|l| l["e"].as_array().unwrap().iter())).find(|e| e.get("fx").is_some()).cloned().unwrap();
assert_eq!((&el["fx"], &el["fm"], &el["bl"]), (&json!([{"k": "blur", "x": 4, "y": 4, "q": 1}]), &json!(3), &json!("subtract")));
assert_eq!(m.report.get(PLUGIN_SCRIPTS), Some(&1));
// The player says so when the frame script's keyframe is entered.
let mut js = Js::new(&m);
js.eval("P.start()");
let lines: Vec<Value> = (0..3).map(|_| js.eval("P.step([]).output")).collect();
assert!(lines[2].to_string().contains("Frame script org.example.menu · main not run"), "{lines:?}");
}
#[test]
fn bitmaps_and_sounds_are_embedded_once() {
let mut doc = Document::default();
let png = {
let mut out = Vec::new();
let mut enc = png::Encoder::new(&mut out, 1, 1);
enc.set_color(png::ColorType::Rgba);
enc.set_depth(png::BitDepth::Eight);
enc.write_header().unwrap().write_image_data(&[255, 0, 0, 255]).unwrap();
out
};
let bitmap = anicraft_doc::Bitmap::from_png(anicraft_doc::BitmapId(50), "dot", png).unwrap();
doc.bitmaps.push(Arc::new(bitmap));
let wav = anicraft_doc::audio::wav::encode(8000, 1, &[0.0; 80], anicraft_doc::audio::wav::Bits::Int16);
doc.sounds.push(Arc::new(anicraft_doc::Sound::from_data(anicraft_doc::SoundId(60), "beep", wav).unwrap()));
let fill = Paint::Bitmap { bitmap: anicraft_doc::BitmapId(50), repeat: true, matrix: Affine::scale(2.0, 2.0) };
let a = Element { id: ElementId(70), name: String::new(), transform: Affine::IDENTITY, color: Default::default(), kind: ElementKind::Shape(Shape::filled(Path::rect(0.0, 0.0, 10.0, 10.0), fill.clone())) };
let b = Element { id: ElementId(71), kind: ElementKind::Shape(Shape::filled(Path::rect(20.0, 0.0, 10.0, 10.0), fill)), ..a.clone() };
{
let k = Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap();
k.elements = vec![Arc::new(a), Arc::new(b)];
k.sound = Some(anicraft_doc::FrameSound::new(anicraft_doc::SoundId(60)));
}
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.stats.images, 1);
assert!(m.json["images"][0].as_str().unwrap().starts_with("data:image/png;base64,iVBOR"));
assert_eq!(m.json["paints"][0], json!({"b": 0, "rep": true, "m": [2, 0, 0, 2, 0, 0]}));
assert_eq!(m.json["sounds"][0]["mime"], "audio/wav");
assert_eq!(m.json["timelines"][0]["snd"]["0"], json!([[0, "event", 1, false, 1]]));
// The player hands the frame's sounds to the page.
let mut js = Js::new(&m);
assert_eq!(js.eval("P.start().sounds"), json!([[0, "event", 1, false, 1, 1, null]]));
let silent = movie(&doc, &HtmlOptions { sound: false, ..Default::default() });
assert_eq!((silent.stats.sounds, silent.json["timelines"][0].get("snd")), (0, None));
// A bitmap without Allow Smoothing says so; the page draws it with hard pixel edges, and
// an SVG frame marks its image pixelated (ADR 0050).
if let Some(b) = doc.bitmaps.first_mut() {
Arc::make_mut(b).smoothing = false;
}
let hard = movie(&doc, &HtmlOptions::default());
assert_eq!(hard.json["paints"][0], json!({"b": 0, "rep": true, "m": [2, 0, 0, 2, 0, 0], "px": true}));
let svg = crate::svg::to_svg(&anicraft_doc::evaluate(&doc, 0), &doc.stage);
assert!(svg.contains("image-rendering=\"pixelated\""), "{svg}");
}
#[test]
fn sounds_carry_their_envelopes_and_volumes_and_start_in_graphics_and_clips_as_in_the_player() {
use anicraft_doc::{FrameSound, Keyframe, Layer, LayerId, SoundEffect, SoundId, SoundSync, Symbol, SymbolId, SymbolKind, Timeline};
let mut doc = Document::default();
doc.stage.fps = 8.0;
let wav = anicraft_doc::audio::wav::encode(8000, 1, &[0.25; 4000], anicraft_doc::audio::wav::Bits::Int16);
doc.sounds.push(Arc::new(anicraft_doc::Sound::from_data(SoundId(60), "beep", wav).unwrap()));
let snd = |sync, effect| Some(FrameSound { sync, effect, ..FrameSound::new(SoundId(60)) });
let key = |start, n, sound: Option<FrameSound>, elements: Vec<Arc<Element>>| {
let mut k = Keyframe::new(start, n);
k.sound = sound;
k.elements = elements;
Arc::new(k)
};
let layer = |id, keys, volume| {
let mut l = Layer::new(LayerId(id), "L");
l.keyframes = keys;
l.volume = volume;
Arc::new(l)
};
let inst = |id, symbol| Arc::new(Element { id: ElementId(id), name: String::new(), transform: Affine::IDENTITY, color: Default::default(), kind: ElementKind::Symbol { symbol: SymbolId(symbol), loop_mode: Default::default(), first_frame: 0, blend: Default::default(), filters: Vec::new(), events: Vec::new() } });
// A graphic with a fading sound on its frame 1 (of 2), a clip with a left-channel one on its
// frame 0 (of 3), both on a layer at half volume; a sound of the main timeline's own.
doc.library.push(Arc::new(Symbol { linkage: None, scale_grid_kept: None, scale_grid: None, id: SymbolId(20), name: "g".into(), kind: SymbolKind::Graphic, timeline: Timeline { layers: vec![layer(21, vec![key(0, 1, None, vec![]), key(1, 1, snd(SoundSync::Event, SoundEffect::FadeOut), vec![])], 1.0)] } }));
doc.library.push(Arc::new(Symbol { linkage: None, scale_grid_kept: None, scale_grid: None, id: SymbolId(30), name: "c".into(), kind: SymbolKind::MovieClip, timeline: Timeline { layers: vec![layer(31, vec![key(0, 3, snd(SoundSync::Stream, SoundEffect::LeftChannel), vec![])], 0.5)] } }));
doc.timeline_mut(0).layers = vec![layer(1, vec![key(0, 6, snd(SoundSync::Event, SoundEffect::None), vec![])], 1.0), layer(2, vec![key(0, 6, None, vec![inst(40, 20), inst(41, 30)])], 0.5)];
let m = movie(&doc, &HtmlOptions::default());
// The fade's points span one play (half a second); the clip's span its 3 frames.
let g_tl = m.json["symbols"].as_array().unwrap().iter().find(|s| s["name"] == "g").unwrap()["tl"].as_u64().unwrap() as usize;
assert_eq!(m.json["timelines"][g_tl]["snd"]["1"], json!([[0, "event", 1, false, 1, 1, [[0, 1, 1], [0.5, 0, 0]]]]));
let c_tl = m.json["symbols"].as_array().unwrap().iter().find(|s| s["name"] == "c").unwrap()["tl"].as_u64().unwrap() as usize;
assert_eq!(m.json["timelines"][c_tl]["snd"]["0"], json!([[0, "stream", 1, false, 3, 0.5, [[0, 1, 0]]]]));
// Frame by frame, the page starts what the Rust player starts, at the same volumes.
let mut js = Js::new(&m);
let mut r = anicraft_doc::player::start(&doc, &mut NoScripts);
let mut ours = js.eval("P.start().sounds");
for step in 0..6 {
let theirs: Vec<Value> = r.sounds.iter().map(|s| json!([s.sound.sound.0 - 60, s.sound.sync.key(), f64::from(s.gain)])).collect();
let page: Vec<Value> = ours.as_array().unwrap().iter().map(|s| json!([s[0], s[1], s[5].as_f64()])).collect();
assert_eq!(page, theirs, "step {step}");
r = anicraft_doc::player::step(&doc, &r.state, &[], &mut NoScripts);
ours = js.eval("P.step([]).sounds");
}
}
#[test]
fn button_sounds_start_in_the_page_as_in_the_player() {
use anicraft_doc::{FrameSound, Sound, SoundId, SoundSync};
// A button at (100, 100), 10 × 10 art, a 100 × 100 Hit frame; a sound on each of its frames
// (Over's a stream) on a layer at half volume; the button's own layer at half volume too.
let mut d = Document::default();
for (i, name) in ["up", "over", "down", "hit"].iter().enumerate() {
let wav = anicraft_doc::audio::wav::encode(8000, 1, &[0.25; 800], anicraft_doc::audio::wav::Bits::Int16);
d.sounds.push(Arc::new(Sound::from_data(SoundId(60 + i as u64), *name, wav).unwrap()));
}
let with = |k: Arc<Keyframe>, i: u64, sync| {
let mut k = (*k).clone();
k.sound = Some(FrameSound { sync, ..FrameSound::new(SoundId(60 + i)) });
Arc::new(k)
};
let mut sounds = (*layer(34, vec![with(kf(0, 1, vec![], vec![], ""), 0, SoundSync::Event), with(kf(1, 1, vec![], vec![], ""), 1, SoundSync::Stream), with(kf(2, 1, vec![], vec![], ""), 2, SoundSync::Event), with(kf(3, 1, vec![], vec![], ""), 3, SoundSync::Event)])).clone();
sounds.volume = 0.5;
let art = || vec![rect(32, 0.0, 0.0, 10.0, 10.0, 0x336699)];
let states = layer(31, vec![kf(0, 1, art(), vec![], ""), kf(1, 1, art(), vec![], ""), kf(2, 1, art(), vec![], ""), kf(3, 1, vec![rect(33, 0.0, 0.0, 100.0, 100.0, 0)], vec![], "")]);
d.library.push(symbol(300, SymbolKind::Button, vec![Arc::new(sounds), states]));
let mut holder = (*layer(2, vec![kf(0, 4, vec![inst(3, 300, "go", Affine::translate(100.0, 100.0), vec![])], vec![], "")])).clone();
holder.volume = 0.5;
d.timeline_mut(0).layers = vec![Arc::new(holder)];
let m = movie(&d, &HtmlOptions::default());
let names: Vec<String> = m.json["sounds"].as_array().unwrap().iter().map(|s| s["name"].as_str().unwrap().to_string()).collect();
assert_eq!(names.len(), 4, "every button sound is embedded");
assert!(m.report.keys().all(|n| !n.contains("button")), "nothing reported: {:?}", m.report);
let mut js = Js::new(&m);
let mut r = start(&d, &mut NoScripts);
js.eval("P.start()");
let at = |x, y| Vec2::new(x, y);
// Over, about, Down, Hit (released), Up (left), Over and Down at once, dragged off and back.
let batches: Vec<Vec<Event>> = vec![
vec![Event::Move(at(150.0, 150.0))],
vec![Event::Move(at(160.0, 150.0))],
vec![Event::Down(at(160.0, 150.0))],
vec![Event::Up(at(160.0, 150.0))],
vec![Event::Leave],
vec![Event::Down(at(150.0, 150.0))],
vec![Event::Move(at(400.0, 300.0)), Event::Move(at(150.0, 150.0)), Event::Up(at(150.0, 150.0))],
];
let mut heard = Vec::new();
for (i, events) in batches.iter().enumerate() {
// Between frames and with a frame, alike.
let (rs, page) = if i % 2 == 0 { (anicraft_doc::player::input(&d, &r.state, events, &mut NoScripts), js.eval(&format!("P.input({}).sounds", js_events(events)))) } else { (step(&d, &r.state, events, &mut NoScripts), js.eval(&format!("P.step({}).sounds", js_events(events)))) };
let theirs: Vec<Value> = rs.sounds.iter().map(|s| json!([d.sound(s.sound.sound).unwrap().name, s.sound.sync.key(), f64::from(s.gain)])).collect();
let ours: Vec<Value> = page.as_array().unwrap().iter().map(|s| json!([names[s[0].as_u64().unwrap() as usize], s[1], s[5].as_f64()])).collect();
assert_eq!(ours, theirs, "batch {i}");
heard.extend(theirs);
r = rs;
}
let order: Vec<&str> = heard.iter().map(|h| h[0].as_str().unwrap()).collect();
assert_eq!(order, ["over", "down", "hit", "up", "over", "down", "hit"]);
assert!(heard.iter().all(|h| h[1] == "event" && h[2] == 0.25), "{heard:?}");
}
#[test]
fn hostile_documents_export_without_panicking() {
let mut doc = Document::default();
let bad = Element { id: ElementId(5), name: "x".into(), transform: Affine { m: [f32::NAN, 0.0, 0.0, 1.0, f32::INFINITY, 0.0] }, color: ColorEffect::Advanced(ColorTransform { mul: [f32::NAN, 2.0, -1.0, f32::INFINITY], add: [f32::NAN, 0.0, 0.0, 0.0] }), kind: ElementKind::Shape(Shape::filled(Path::rect(0.0, 0.0, f32::NAN, 1.0), Paint::radial(Vec2::ZERO, -5.0, vec![GradientStop { offset: f32::NAN, color: Rgba::BLACK }]))) };
let fine = Element { id: ElementId(6), transform: Affine::IDENTITY, ..bad.clone() };
let missing = inst(7, 12345, "ghost", Affine::IDENTITY, vec![]);
Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap().elements = vec![Arc::new(bad), Arc::new(fine), missing];
to_html(&doc, &HtmlOptions::default()).unwrap();
let m = movie(&doc, &HtmlOptions::default());
let data = m.json.to_string();
assert!(!data.contains("NaN") && !data.contains("inf") && !data.contains("null,"), "numbers stay finite: {data}");
assert_eq!(m.json["paths"][0], "", "a path with a NaN point is left empty");
let mut js = Js::new(&m);
js.eval("P.start()");
js.eval("P.step([{type: 'move', x: 1, y: 1}])");
// An empty document is a one-frame movie.
let m = movie(&Document::default(), &HtmlOptions::default());
assert_eq!(m.json["timelines"][0]["n"], 1);
}
/// `k` with a kept ActionScript 3.0 script in place of its actions.
fn as3(k: &mut Arc<Keyframe>, src: &str) {
Arc::make_mut(k).script = Some(FrameScript::Source(Arc::new(anicraft_doc::actions::SourceScript::new(anicraft_doc::actions::Language::ActionScript3, src))));
}
/// The fixture with its frame actions and the knob's handlers written as ActionScript: the
/// main timeline's first frame adds the knob's listeners (named and inline functions,
/// `currentTarget`), a listener makes the panel clip clickable, one names an instance that
/// isn't there, the door's last frame calls `nextScene()` in its own script, and a script
/// outside the subset stays kept and unrun.
fn scripted() -> Document {
let mut d = fixture();
let main = "import flash.events.MouseEvent;\n\
trace(\"start\");\n\
knob.addEventListener(MouseEvent.CLICK, openDoor);\n\
knob.addEventListener(MouseEvent.ROLL_OVER, function (e:MouseEvent):void { door.alpha = 0.5; });\n\
knob.addEventListener(MouseEvent.ROLL_OUT, function (e:MouseEvent):void { door.alpha = 1; });\n\
knob.addEventListener(MouseEvent.MOUSE_DOWN, pressed);\n\
knob.addEventListener(MouseEvent.MOUSE_UP, released);\n\
panel.addEventListener(MouseEvent.CLICK, function (e:MouseEvent):void { trace(\"panel \" + 1); MovieClip(e.currentTarget).gotoAndStop(1); e.currentTarget.alpha = 0.75; });\n\
ghost.addEventListener(MouseEvent.CLICK, pressed);\n\
navigateToURL(new URLRequest(\"https://example.com\"));\n\
function openDoor(e:MouseEvent):void { door.gotoAndPlay(\"opening\"); panel.door.play(); }\n\
function pressed(e:MouseEvent):void { trace(\"pressed\"); }\n\
function released(e:MouseEvent):void { MovieClip(root).panel.gotoAndStop(100); }";
let tl = d.timeline_mut(0);
let l1 = Arc::make_mut(&mut tl.layers[0]);
as3(&mut l1.keyframes[0], main);
as3(&mut l1.keyframes[1], "ghost.stop()\npanel.stop()");
as3(&mut l1.keyframes[2], "var n:int = 3; stop(); switch (n) { }");
let l2 = Arc::make_mut(&mut tl.layers[1]);
if let ElementKind::Symbol { events, .. } = &mut Arc::make_mut(&mut Arc::make_mut(&mut l2.keyframes[0]).elements[0]).kind {
events.clear();
}
let door = Arc::make_mut(&mut d.library[0]);
let dl = Arc::make_mut(&mut door.timeline.layers[0]);
as3(&mut dl.keyframes[2], "stop();\ntrace('door open');\nnextScene();");
d
}
#[test]
fn the_js_player_runs_actionscript_like_the_rust_player() {
let doc = scripted();
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.report.get(KEPT_SCRIPTS), Some(&1), "{:?}", m.report);
assert_eq!(m.report.get(OUTSIDE_CALLS), Some(&1), "{:?}", m.report);
let none = || (vec![], vec![]);
let mut script: Vec<(Vec<Event>, Vec<Event>)> = (0..2).map(|_| none()).collect();
script.push((vec![Event::Move(at(100.0, 100.0))], vec![]));
script.push((vec![Event::Down(at(101.0, 99.0))], vec![]));
script.push((vec![], vec![Event::Up(at(102.0, 101.0))]));
script.extend((0..6).map(|_| none()));
// Click the panel (a movie clip that a listener made clickable).
script.push((vec![Event::Move(at(380.0, 300.0))], vec![Event::Down(at(380.0, 300.0)), Event::Up(at(380.0, 300.0))]));
script.push((vec![Event::Move(at(10.0, 10.0)), Event::Leave], vec![]));
script.extend((0..30).map(|_| none()));
let lines = compare(&doc, &script);
for want in ["start", "pressed", "door open", "panel 1", "Listen for click (ghost): no instance named “ghost” here", "Stop (ghost): no instance named “ghost” here", "Next scene: a movie clip's timeline has one scene; call it in the main timeline's script"] {
assert!(lines.iter().any(|l| l == want), "the scripted fixture never wrote {want:?}: {lines:?}");
}
}
#[test]
fn actionscript_plays_the_movie_its_hand_made_actions_play() {
// The scripted fixture and the fixture write the same lines and reach the same states, but
// for the lines only scripts write and the listeners they hold.
let (a, b) = (fixture(), scripted());
let events = [vec![], vec![], vec![Event::Move(at(100.0, 100.0))], vec![Event::Down(at(101.0, 99.0))], vec![Event::Up(at(102.0, 101.0))], vec![], vec![], vec![], vec![Event::Move(at(10.0, 10.0))]];
let (mut x, mut y) = (start(&a, &mut NoScripts), start(&b, &mut NoScripts));
let only_scripts = |l: &String| l.starts_with("Listen for") || l.starts_with("Next scene:");
for (i, ev) in events.iter().enumerate() {
x = step(&a, &x.state, ev, &mut NoScripts);
y = step(&b, &y.state, ev, &mut NoScripts);
let ys: Vec<&String> = y.output.iter().filter(|l| !only_scripts(l)).collect();
assert_eq!(x.output.iter().collect::<Vec<_>>(), ys, "step {}: output", i + 1);
let mut st = y.state.clone();
st.listeners.clear();
st.seq = 0;
assert_eq!(x.state, st, "step {}: state", i + 1);
}
}
/// A movie that uses the small-logic tier (ADR 0052): typed variables kept per
/// timeline and per clip instance, expressions, `if`, loops, `Math.random()`, functions from
/// another frame, property reads, enter-frame and keyboard listeners that add and remove
/// themselves, `e.target`, a runtime error and a loop that runs out of fuel.
fn logic() -> Document {
let mut d = fixture();
let main = "import flash.events.*;\n\
var score:int = 0;\n\
var label:String = \"go\";\n\
var ticks:uint;\n\
var total:Number = 0;\n\
trace(\"start \" + score + \" \" + label + \" \" + ticks + \" \" + currentFrame + \"/\" + totalFrames + \" \" + currentLabel);\n\
for (var i:int = 0; i < 5; i++) { if (i % 2 == 0) continue; total += i * 1.5; }\n\
var k:int = 3; while (k > 0) { k--; } do { k += 2; } while (k < 5);\n\
trace(total, k, Math.max(1, 7, 3), Math.min(), Math.round(-2.5), Math.abs(-0.25), int(\"42\") + uint(-1), 7 / 2, \"10\" < \"9\", 1 == \"1\", null == undefined);\n\
trace(Math.floor(Math.random() * 100), Math.random() < 1, knob.x, knob.y, knob.alpha, knob.visible, knob.name, panel.currentFrame, panel.totalFrames);\n\
addEventListener(Event.ENTER_FRAME, onTick);\n\
stage.addEventListener(KeyboardEvent.KEY_DOWN, onKey);\n\
stage.addEventListener(KeyboardEvent.KEY_UP, function (e:KeyboardEvent):void { trace(\"up \" + e.keyCode + \" \" + (e.currentTarget == stage)); });\n\
knob.addEventListener(MouseEvent.CLICK, function (e:MouseEvent):void { score += 10; trace(\"click \" + e.target.name + \" \" + (e.currentTarget == knob) + \" \" + score); door.x = door.x + 0.1; trace(door.x); });\n\
function onTick(e:Event):void {\n\
ticks++;\n\
if (ticks % 4 == 0) trace(\"tick \" + ticks + \" frame \" + currentFrame + \" mouse \" + mouseX + \",\" + mouseY);\n\
if (ticks >= 12) { removeEventListener(Event.ENTER_FRAME, onTick); trace(\"stopped ticking\"); }\n\
}\n\
function onKey(e:KeyboardEvent):void {\n\
if (e.keyCode == Keyboard.RIGHT) { knob.x += 5; } else if (e.keyCode == Keyboard.SPACE) { trace(\"space \" + bump(2)); } else { trace(\"key \" + e.keyCode); }\n\
trace(\"knob at \" + knob.x + \" \" + label);\n\
}";
let tl = d.timeline_mut(0);
let l1 = Arc::make_mut(&mut tl.layers[0]);
as3(&mut l1.keyframes[0], main);
as3(&mut l1.keyframes[1], "function bump(n:int):int { score += n; return score % 3 + 1; }\nlabel = label + \"!\";\ntrace(\"frame 2: \" + bump(1) + \" \" + label);\ntrace(ghost.x);\ntrace(\"never\");");
as3(&mut l1.keyframes[2], "var spin:int = 0; while (true) { spin++; }");
let l2 = Arc::make_mut(&mut tl.layers[1]);
if let ElementKind::Symbol { events, .. } = &mut Arc::make_mut(&mut Arc::make_mut(&mut l2.keyframes[0]).elements[0]).kind {
events.clear();
}
// The door clip keeps its own count across its loops.
let door = Arc::make_mut(&mut d.library[0]);
let dl = Arc::make_mut(&mut door.timeline.layers[0]);
as3(&mut dl.keyframes[0], "var laps:int; laps++; if (laps > 1) trace(\"door lap \" + laps);");
d
}
#[test]
fn the_js_player_runs_small_logic_like_the_rust_player() {
let doc = logic();
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.report.get(KEPT_SCRIPTS), None, "every script links: {:?}", m.report);
assert!(m.json["timelines"][0]["fn"]["bump"].is_object() && m.json["timelines"][0]["vt"]["score"] == "int", "{}", m.json["timelines"][0]["vt"]);
let none = || (vec![], vec![]);
let mut script: Vec<(Vec<Event>, Vec<Event>)> = vec![none()];
script.push((vec![Event::Move(at(100.0, 100.0))], vec![]));
script.push((vec![Event::Down(at(101.0, 99.0))], vec![Event::Up(at(101.0, 99.0))]));
script.push((vec![Event::KeyDown(39), Event::KeyUp(39)], vec![Event::KeyDown(65)]));
script.push((vec![Event::KeyDown(32)], vec![]));
script.extend((0..14).map(|_| none()));
script.push((vec![Event::Move(at(10.0, 10.0)), Event::Leave], vec![Event::KeyDown(39)]));
script.extend((0..20).map(|_| none()));
let lines = compare(&doc, &script);
for want in ["start 0 go 0 1/33 null", "6 6 7 Infinity -2 0.25 4294967337 3.5 true true true", "10 true 100 100 1 true knob 1 4", "frame 2: 2 go!", "Script on frame 4 of the main timeline stopped: line 4: no instance named “ghost” here", "stopped ticking", "up 39 true", "key 65"] {
assert!(lines.iter().any(|l| l == want), "the logic fixture never wrote {want:?}: {lines:?}");
}
assert!(lines.iter().any(|l| l == "click knob true 11"), "{lines:?}");
assert!(lines.iter().any(|l| l.ends_with("ran more than 100000 steps (an endless loop?)")), "{lines:?}");
assert!(!lines.iter().any(|l| l == "never"));
}
#[test]
fn the_js_player_draws_random_numbers_like_the_rust_player() {
// The seeded generator, number for number, at several seeds.
for seed in [0u64, 1, 7, 0xdead_beef, u64::from(u32::MAX) + 5] {
let mut d = Document::default();
let k = Arc::make_mut(&mut Arc::make_mut(&mut d.timeline_mut(0).layers[0]).keyframes[0]);
k.script = Some(FrameScript::Source(Arc::new(anicraft_doc::actions::SourceScript::new(anicraft_doc::actions::Language::ActionScript3, "for (var i:int = 0; i < 20; i++) trace(Math.random());"))));
let m = movie(&d, &HtmlOptions::default());
let rust = anicraft_doc::player::start_seeded(&d, seed, &mut NoScripts).output;
let mut js = Js::new(&m);
js.eval(&format!("(P = new AniCraft.Player({}, host, {seed}), 0)", m.json));
assert_eq!(js.eval("P.start().output"), json!(rust), "seed {seed}");
}
}
/// A text field element (ADR 0066): `text` in a `w` × `h` box at `at`, its outline a stand-in
/// (layout isn't compared: neither player lays text out here).
fn field_el(id: u64, name: &str, at: Vec2, (w, h): (f32, f32), text: &str, f: Option<anicraft_doc::TextField>) -> Arc<Element> {
let n = text.chars().count() as f32;
let t = anicraft_doc::TextBlock { text: text.into(), font: "Inter".into(), size: 14.0, bold: true, italic: false, color: Rgba::hex(0x112233), align: anicraft_doc::TextAlign::Center, letter_spacing: 0.5, line_spacing: 2.0, width: None, outline: Arc::new(Path::rect(2.0, 2.0, 8.0 * n, 12.0)), box_width: w, box_height: h, field: f, on_path: None };
Arc::new(Element { id: ElementId(id), name: name.into(), transform: Affine::translate(at.x, at.y), color: ColorEffect::default(), kind: ElementKind::Text(Arc::new(t)) })
}
/// A movie with a dynamic field (`score_txt`, with a background and a border), an input field
/// (`name_txt`, at most 5 characters) and a movie clip (`door`): frame scripts set, append and
/// read text and length, name a field that isn't there, a clip and the main timeline as fields,
/// set text to null, give a field a playhead, and a keyboard listener copies what was typed into
/// the dynamic field until a key takes the movie to a frame without the fields.
fn fields_doc() -> Document {
use anicraft_doc::{TextField, TextKind};
let mut d = Document { stage: anicraft_doc::Stage { width: 200, height: 100, fps: 24.0, background: Rgba::hex(0xffffff) }, ..Document::default() };
d.library = vec![symbol(100, SymbolKind::MovieClip, vec![layer(101, vec![kf(0, 1, vec![rect(1001, 0.0, 0.0, 20.0, 20.0, 0x884422)], vec![], "")])])];
let mut score = TextField::new(TextKind::Dynamic);
(score.background, score.background_color, score.border, score.border_color) = (true, Rgba::hex(0xffffee), true, Rgba::hex(0x333333));
let mut name = TextField::new(TextKind::Input);
(name.max_chars, name.border) = (5, true);
let fields = vec![field_el(50, "score_txt", Vec2::new(10.0, 10.0), (100.0, 20.0), "Score", Some(score)), field_el(51, "name_txt", Vec2::new(10.0, 40.0), (120.0, 20.0), "", Some(name)), inst(52, 100, "door", Affine::translate(150.0, 60.0), vec![])];
let mut scripts = layer(1, (0..8).map(|f| kf(f, 1, vec![], vec![], "")).collect());
let main = "import flash.events.*;\n\
score_txt.text = \"Score: \" + 1;\n\
score_txt.appendText(\"0\");\n\
trace(score_txt.text + \" \" + score_txt.length);\n\
trace(\"[\" + name_txt.text + \"] \" + name_txt.length);\n\
name_txt.x = 12;\n\
trace(name_txt.x, name_txt.name);\n\
stage.addEventListener(KeyboardEvent.KEY_DOWN, onKey);\n\
function onKey(e:KeyboardEvent):void {\n\
if (e.keyCode == 39) gotoAndStop(8);\n\
else { score_txt.text = name_txt.text + \":\" + e.keyCode; trace(score_txt.text, name_txt.length); }\n\
}";
let frames = [main, "ghost_txt.text = \"x\";", "door.text = \"x\";", "trace(door.length);", "trace(root.text);", "score_txt.text = null;", "stop();\nscore_txt.gotoAndStop(1);\nscore_txt.text = \"a\\r\\nb\\rc\";\ntrace(score_txt.length);\ntrace(score_txt.currentFrame);", "trace(\"gone\");"];
{
let l = Arc::make_mut(&mut scripts);
for (k, src) in l.keyframes.iter_mut().zip(frames) {
as3(k, src);
}
}
d.timeline_mut(0).layers = vec![scripts, layer(2, vec![kf(0, 7, fields, vec![], ""), kf(7, 1, vec![], vec![], "")])];
d.sanitize();
d
}
#[test]
fn the_js_player_runs_text_fields_like_the_rust_player() {
let doc = fields_doc();
let m = movie(&doc, &HtmlOptions::default());
assert_eq!(m.report.get(KEPT_SCRIPTS), None, "every script runs: {:?}", m.report);
let none = || (vec![], vec![]);
let mut script: Vec<(Vec<Event>, Vec<Event>)> = (0..6).map(|_| none()).collect();
let name = at(30.0, 50.0);
// Click the input field, type at the end (past its limit), delete, select all and replace,
// Tab (the only input field: it selects all), type again; then the dynamic field (it takes
// the keyboard but not typing) and the stage (nothing has it).
script.push((vec![Event::Down(name), Event::Up(name)], vec![]));
script.push((vec![Event::Char('A'), Event::Char('n'), Event::Char('n')], vec![Event::KeyDown(65), Event::KeyUp(65)]));
script.push((vec![Event::Char('a'), Event::Char('b'), Event::Char('c')], vec![Event::KeyDown(8)]));
script.push((vec![Event::SelectAll, Event::Char('Z'), Event::KeyDown(13), Event::KeyUp(13)], vec![]));
script.push((vec![Event::KeyDown(9)], vec![Event::Char('Q'), Event::KeyDown(65)]));
script.push((vec![Event::Down(at(20.0, 15.0)), Event::Up(at(20.0, 15.0))], vec![Event::Char('x')]));
script.push((vec![Event::Down(at(190.0, 95.0)), Event::Up(at(190.0, 95.0))], vec![Event::Char('y'), Event::KeyDown(66)]));
// Right arrow: to a frame without the fields (their text and the focus go with them).
script.push((vec![Event::Down(name), Event::Up(name)], vec![Event::KeyDown(39)]));
script.push((vec![Event::KeyDown(65)], vec![]));
script.extend((0..2).map(|_| none()));
let lines = compare(&doc, &script);
for want in [
"Score: 10 9",
"[] 0",
"12 name_txt",
"Script on frame 2 of the main timeline stopped: line 1: no instance named “ghost_txt” here",
"Script on frame 3 of the main timeline stopped: line 1: “door” is a movie clip, not a text field",
"Script on frame 4 of the main timeline stopped: line 1: “door” is a movie clip, not a text field",
"Script on frame 5 of the main timeline stopped: line 1: the main timeline isn't a text field",
"Script on frame 6 of the main timeline stopped: line 1: `text` is set to text, not null",
"Go to frame 1 and stop (score_txt): “score_txt” is a text field; only movie clips and the main timeline have a playhead",
"5",
"Script on frame 7 of the main timeline stopped: line 5: “score_txt” is a text field; only movie clips and the main timeline have frames",
"Ann:65 3",
"Anna:8 4",
// Enter types nothing in a one-line field; Tab (to the same field) selects all of it.
"Z:13 1",
"Z:9 1",
"Q:65 1",
"Q:66 1",
"gone",
] {
assert!(lines.iter().any(|l| l == want), "the fields movie never wrote {want:?}: {lines:?}");
}
assert!(lines.iter().any(|l| l.starts_with("Listener onKey stopped: line ") && l.ends_with("no instance named “name_txt” here")), "{lines:?}");
}
#[test]
fn text_fields_export_as_named_instances_and_static_text_as_before() {
use anicraft_doc::{LineType, TextField, TextKind};
let mut doc = Document::default();
let mut pass = TextField::new(TextKind::Input);
(pass.lines, pass.max_chars) = (LineType::Password, 5);
let mut note = TextField::new(TextKind::Dynamic);
(note.lines, note.selectable, note.background, note.border) = (LineType::Multiline, false, true, true);
let els = vec![field_el(60, "", Vec2::new(5.0, 5.0), (40.0, 16.0), "Hi", None), field_el(61, "note_txt", Vec2::new(5.0, 30.0), (150.0, 40.0), "Hello", Some(note)), field_el(62, "pass_txt", Vec2::new(5.0, 80.0), (90.0, 18.0), "", Some(pass))];
let ElementKind::Text(static_text) = &els[0].kind else { panic!("the first element is text") };
let outline = static_text.outline.clone();
Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap().elements = els;
let m = movie(&doc, &HtmlOptions::default());
let items = &m.json["contents"][0]["l"][0]["e"];
// Static text: a shape, its outline filled in its colour, as before.
let s = &items[0];
assert_eq!(s.as_object().unwrap().keys().collect::<Vec<_>>(), ["f", "m", "p"], "{s}");
assert_eq!(m.json["paths"][s["p"].as_u64().unwrap() as usize], path_data(&outline));
assert_eq!(m.json["paints"][s["f"].as_u64().unwrap() as usize], json!({"s": color(Rgba::hex(0x112233))}));
// A field: an instance with its name, box, kind, text and font.
let f = &items[1];
assert_eq!((f["id"].as_u64(), f["n"].as_str(), &f["m"]), (Some(61), Some("note_txt"), &json!([1, 0, 0, 1, 5, 30])));
let tf = &f["tf"];
assert_eq!((tf["k"].as_str(), tf["ln"].as_str(), tf["w"].as_f64(), tf["h"].as_f64(), tf["sel"].as_bool(), tf["t"].as_str()), (Some("dynamic"), Some("multiline"), Some(150.0), Some(40.0), Some(false), Some("Hello")));
assert_eq!(tf["font"], json!({"family": "Inter", "size": 14, "bold": true, "italic": false, "align": "center", "ls": 0.5, "lsp": 2}));
assert_eq!((&tf["bd"], &tf["bk"]["j"]), (&json!([0, 0, 0, 1, 1]), &json!("miter")), "a 1 px mitred border");
assert_eq!(m.json["paints"][tf["bg"].as_u64().unwrap() as usize], json!({"s": [1, 1, 1, 1]}));
assert!(tf.get("mx").is_none());
let p = &items[2]["tf"];
assert_eq!((p["k"].as_str(), p["ln"].as_str(), p["mx"].as_u64(), p.get("bg"), p.get("bd")), (Some("input"), Some("password"), Some(5), None, None));
assert_eq!(m.report.get(FIELD_FONTS), Some(&2), "{:?}", m.report);
// The page's calls: the viewer types into the input field, the keyboard moves.
let mut js = Js::new(&m);
js.eval("P.start()");
assert_eq!(js.eval("P.typed('62', 'Hello\\nWorld')"), json!("Hello"), "one line, at most 5 characters");
assert_eq!(js.eval("[P.fieldText('62'), P.fieldText('61'), P.fieldText('60')]"), json!(["Hello", "Hello", null]));
assert_eq!(js.eval("P.typed('61', 'x')"), Value::Null, "a dynamic field isn't typed into");
assert_eq!(js.eval("[P.focus('62'), P.snapshot().focus, P.focus('61'), P.focus(null), P.snapshot().focus]"), json!([true, [62], false, false, null]));
// The page hears each field as one, with its text, in place of its items.
let seen = js.eval("(function () { var out = []; P.evaluate({ item: function () {}, field: function (f) { out.push([f.key, f.text, f.tf.k, f.items.length]); }, clipBegin: function () {}, clipEnd: function () {}, maskBegin: function () {}, maskEnd: function () {}, groupBegin: function () {}, groupEnd: function () {} }); return out; })()");
assert_eq!(seen, json!([["61", null, "dynamic", 4], ["62", "Hello", "input", 1]]));
}
// ----- filters and per-pixel blending in the page (ADR 0072) ------------------------------------
/// A JavaScript engine with the page's filters.
fn filters_js() -> Context {
let mut ctx = Context::default();
ctx.eval(Source::from_bytes(FILTERS_JS)).unwrap_or_else(|e| panic!("filters.js: {e}"));
ctx
}
fn js_json(ctx: &mut Context, code: &str) -> Value {
let v = ctx.eval(Source::from_bytes(&format!("JSON.stringify({code})"))).unwrap_or_else(|e| panic!("{code}: {e}"));
let s = v.to_string(ctx).unwrap().to_std_string_escaped();
serde_json::from_str(&s).unwrap_or_else(|e| panic!("{code}: {e}: {s}"))
}
fn stop(offset: f32, c: u32, a: f32) -> GradientStop {
GradientStop { offset, color: Rgba::hex(c).with_alpha(a) }
}
/// Every filter, with each of its sides, knockouts and switches, and stacks of them.
fn filter_cases() -> Vec<Vec<anicraft_doc::Filter>> {
use anicraft_doc::{Filter, FilterSide};
let ds = |inner, knockout, hide_object, angle: f32| Filter::DropShadow { blur_x: 6.0, blur_y: 3.0, strength: 1.3, quality: 2, angle, distance: 5.0, color: Rgba::new(0.1, 0.2, 0.6, 0.8), inner, knockout, hide_object };
let glow = |inner, knockout| Filter::Glow { blur_x: 7.0, blur_y: 7.0, strength: 2.0, quality: 3, color: Rgba::hex(0xffcc00), inner, knockout };
let bevel = |side, knockout| Filter::Bevel { blur_x: 4.0, blur_y: 5.0, strength: 1.5, quality: 1, angle: 45.0, distance: 3.0, shadow_color: Rgba::hex(0x000033), highlight_color: Rgba::WHITE.with_alpha(0.9), side, knockout };
let ramp = vec![stop(0.0, 0xffffff, 0.0), stop(0.4, 0x00ff00, 1.0), stop(1.0, 0x0000ff, 1.0)];
let gglow = |side, knockout| Filter::GradientGlow { blur_x: 5.0, blur_y: 8.0, strength: 1.0, quality: 2, angle: 120.0, distance: 4.0, stops: ramp.clone(), side, knockout };
let bramp = vec![stop(0.0, 0xffff00, 1.0), stop(0.5, 0, 0.0), stop(0.8, 0xff00ff, 0.7), stop(1.0, 0x000000, 1.0)];
let gbevel = |side, knockout| Filter::GradientBevel { blur_x: 3.0, blur_y: 3.0, strength: 2.0, quality: 2, angle: 225.0, distance: 2.0, stops: bramp.clone(), side, knockout };
let mut out = vec![
vec![Filter::Blur { blur_x: 5.0, blur_y: 2.0, quality: 1 }],
vec![Filter::Blur { blur_x: 8.0, blur_y: 8.0, quality: 3 }],
vec![Filter::AdjustColor { brightness: 20.0, contrast: 30.0, saturation: -40.0, hue: 75.0 }],
vec![Filter::AdjustColor { brightness: -50.0, contrast: -20.0, saturation: 60.0, hue: -150.0 }],
];
for (inner, knockout, hide) in [(false, false, false), (true, false, false), (false, true, false), (true, true, false), (false, false, true), (true, false, true)] {
out.push(vec![ds(inner, knockout, hide, 45.0)]);
}
out.push(vec![ds(false, false, false, 200.0)]);
for (inner, knockout) in [(false, false), (true, false), (false, true), (true, true)] {
out.push(vec![glow(inner, knockout)]);
}
for side in FilterSide::ALL {
for knockout in [false, true] {
out.push(vec![bevel(side, knockout)]);
out.push(vec![gglow(side, knockout)]);
out.push(vec![gbevel(side, knockout)]);
}
}
// Stacks: each filter works on what the one before made.
out.push(vec![ds(false, false, false, 45.0), bevel(FilterSide::Inner, false), Filter::AdjustColor { brightness: 0.0, contrast: 10.0, saturation: 20.0, hue: 30.0 }]);
out.push(vec![Filter::Blur { blur_x: 3.0, blur_y: 3.0, quality: 2 }, glow(false, false), gglow(FilterSide::Full, false)]);
out
}
/// A movie clip with a gradient, a translucent shape and a stroke (soft edges everywhere), on a
/// small stage, with `filters`.
fn filtered_doc(filters: &[anicraft_doc::Filter]) -> Document {
let mut d = Document { stage: anicraft_doc::Stage { width: 64, height: 56, fps: 24.0, background: Rgba::WHITE }, ..Document::default() };
let grad = Paint::linear(Vec2::new(0.0, 0.0), Vec2::new(24.0, 18.0), vec![stop(0.0, 0xff3300, 1.0), stop(1.0, 0x3366ff, 0.6)]);
let mut a = Shape::filled(Path::ellipse(12.0, 10.0, 11.0, 8.5), grad);
a.stroke = Some(anicraft_doc::Stroke::new(Rgba::hex(0x112233), 1.5));
let b = Shape::filled(Path::rect(16.3, 4.6, 9.2, 13.7), Paint::Solid(Rgba::hex(0x22aa44).with_alpha(0.5)));
let el = |id, s| Arc::new(Element { id: ElementId(id), name: String::new(), transform: Affine::IDENTITY, color: ColorEffect::default(), kind: ElementKind::Shape(s) });
d.library.push(symbol(300, SymbolKind::MovieClip, vec![layer(301, vec![kf(0, 1, vec![el(302, a), el(303, b)], vec![], "")])]));
let mut i = (*inst(310, 300, "art", Affine::translate(18.4, 15.2), vec![])).clone();
if let ElementKind::Symbol { filters: f, .. } = &mut i.kind {
*f = filters.to_vec();
}
Arc::make_mut(&mut d.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap().elements = vec![Arc::new(i)];
d
}
/// The first filtered instance in the movie's data: its filters (`fx`) and their reach (`fm`).
fn exported_filters(m: &Movie) -> (Value, Value) {
let e = m.json["contents"].as_array().unwrap().iter().flat_map(|c| c["l"].as_array().unwrap().iter().flat_map(|l| l["e"].as_array().unwrap().iter())).find(|e| e.get("fx").is_some()).cloned().expect("a filtered instance");
(e["fx"].clone(), e["fm"].clone())
}
/// What the page makes of the oracle's unfiltered layer `l` (its pixels `pm`) at view scale
/// `scale`: the layer placed with 7 more pixels around it, as the page's canvas layer reaches past
/// the oracle's, cut by `region` and filtered there by `filters.js`. Returns the oracle's layer
/// filtered by the oracle beside the page's, both over the page's larger rectangle (`x0`, `y0`,
/// `w`, `h` in surface pixels; zero where either has nothing).
/// A rectangle in surface pixels (`x0`, `y0`, `w`, `h`), the page's pixels over it and the
/// oracle's.
type Filtered = ((i32, i32, usize, usize), Vec<[f32; 4]>, Vec<[f32; 4]>);
fn page_and_oracle_filtered(js: &mut Context, l: &crate::FilterLayer, pm: &[crate::paint::Premul], filters: &[anicraft_doc::Filter], (fx, fm): &(Value, Value), scale: f32) -> Filtered {
let (w, h) = (l.bounds.width(), l.bounds.height());
let mut want = pm.to_vec();
crate::filters::apply(&mut want, w, h, filters, scale);
let pad = 7;
let (bw, bh) = (w + 2 * pad, h + 2 * pad);
let mut big = vec![0.0f32; bw * bh * 4];
for y in 0..h {
for x in 0..w {
big[((y + pad) * bw + x + pad) * 4..][..4].copy_from_slice(&pm[y * w + x]);
}
}
let code = format!(
"(function () {{ var b = new Float32Array({big}); var r = AniCraftFilters.region(b, {bw}, {bh}, AniCraftFilters.reach({fm}, {scale})); if (!r) return null; var w = r[2] - r[0], h = r[3] - r[1]; var c = new Float32Array(w * h * 4); for (var y = 0; y < h; y++) for (var x = 0; x < w * 4; x++) c[y * w * 4 + x] = b[((y + r[1]) * {bw} + r[0]) * 4 + x]; AniCraftFilters.apply(c, w, h, {fx}, {scale}); return {{ r: r, c: Array.from(c) }}; }})()",
big = json!(big),
);
let out = js_json(js, &code);
let r: Vec<usize> = out["r"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap() as usize).collect();
let c: Vec<f32> = out["c"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap() as f32).collect();
let cw = r[2] - r[0];
let (mut page, mut oracle) = (Vec::with_capacity(bw * bh), Vec::with_capacity(bw * bh));
for y in 0..bh {
for x in 0..bw {
let inside = (r[0]..r[2]).contains(&x) && (r[1]..r[3]).contains(&y);
page.push(if inside { c[((y - r[1]) * cw + x - r[0]) * 4..][..4].try_into().unwrap() } else { [0.0; 4] });
oracle.push(if (pad..pad + w).contains(&x) && (pad..pad + h).contains(&y) { want[(y - pad) * w + x - pad] } else { [0.0; 4] });
}
}
((l.bounds.x0 - pad as i32, l.bounds.y0 - pad as i32, bw, bh), page, oracle)
}
/// The page's filters on the oracle's own unfiltered layer, placed with room around it as the
/// page's canvas layer is, cut to where they can reach (`region`) and filtered there, give the
/// oracle's filtered layer: every filter, side and switch, alone and stacked, at whole and
/// fractional view scales.
#[test]
fn the_pages_filters_give_the_renderers_pixels() {
let mut js = filters_js();
let mut worst = 0.0f32;
for (n, filters) in filter_cases().into_iter().enumerate() {
let doc = filtered_doc(&filters);
let m = movie(&doc, &HtmlOptions::default());
let exported = exported_filters(&m);
assert_eq!(exported.0.as_array().map(Vec::len), Some(filters.len()), "case {n}");
let dl = anicraft_doc::evaluate(&doc, 0);
// Every case at the stage size, and at a fractional or a double view scale in turn.
for scale in [1.0f32, if n % 2 == 0 { 1.5 } else { 2.0 }] {
let view = crate::View { transform: Affine::scale(scale, scale), width: (64.0 * scale) as u32, height: (56.0 * scale) as u32, background: None };
let (scene, _) = crate::prepare_scene(&dl, &view).unwrap();
let [l] = scene.layers.as_slice() else { panic!("case {n}: one filtered layer") };
let (pm, _) = crate::render(&l.list, &l.view).unwrap();
let (_, page, oracle) = page_and_oracle_filtered(&mut js, l, &pm.data, &dl.groups[0].filters, &exported, scale);
for (i, (p, o)) in page.iter().zip(&oracle).enumerate() {
for k in 0..4 {
let d = (p[k] - o[k]).abs();
worst = worst.max(d);
assert!(d < 2e-3, "case {n} {filters:?} at ×{scale}, pixel {i} channel {k}: page {p:?}, renderer {o:?}");
}
}
}
}
eprintln!("largest difference from the renderer: {worst:e}");
}
/// A filtered movie clip under a soft mask (`inside` false: a mask layer on the stage over the
/// layer with the instance), or a soft mask inside the filtered symbol (`inside` true: the
/// symbol's own mask layer over its artwork). The mask is a gradient from opaque white through
/// half-transparent grey to faint black, so alpha and luminance reveal differently.
fn soft_masked_doc(mode: anicraft_doc::MaskMode, inside: bool) -> Document {
use anicraft_doc::{Filter, FilterSide};
let filters = vec![
Filter::DropShadow { blur_x: 5.0, blur_y: 5.0, strength: 1.0, quality: 2, angle: 45.0, distance: 4.0, color: Rgba::new(0.1, 0.0, 0.3, 1.0), inner: false, knockout: false, hide_object: false },
Filter::Bevel { blur_x: 3.0, blur_y: 3.0, strength: 1.2, quality: 1, angle: 45.0, distance: 2.0, shadow_color: Rgba::BLACK, highlight_color: Rgba::WHITE, side: FilterSide::Inner, knockout: false },
Filter::Glow { blur_x: 6.0, blur_y: 6.0, strength: 1.5, quality: 2, color: Rgba::hex(0xffcc00), inner: false, knockout: false },
];
let mut d = filtered_doc(&filters);
let ramp = Paint::linear(Vec2::new(10.0, 0.0), Vec2::new(54.0, 0.0), vec![stop(0.0, 0xffffff, 1.0), stop(0.5, 0x808080, 0.5), stop(1.0, 0x000000, 0.2)]);
let art = Arc::new(Element { id: ElementId(320), name: String::new(), transform: Affine::IDENTITY, color: ColorEffect::default(), kind: ElementKind::Shape(Shape::filled(Path::rect(10.0, 4.0, 44.0, 48.0), ramp)) });
let mut mask = Layer::new(LayerId(321), "mask");
mask.kind = LayerKind::Mask;
mask.mask_mode = mode;
if inside {
// In the symbol's space (the instance sits at 18.4, 15.2).
let mut a = (*art).clone();
a.transform = Affine::translate(-18.4, -15.2);
mask.keyframes = vec![kf(0, 1, vec![Arc::new(a)], vec![], "")];
let sym = d.library.iter_mut().find(|s| s.id == SymbolId(300)).unwrap();
let tl = &mut Arc::make_mut(sym).timeline;
let mut masked = (*tl.layers[0]).clone();
masked.parent = Some(LayerId(321));
tl.layers = vec![Arc::new(mask), Arc::new(masked)];
} else {
mask.keyframes = vec![kf(0, 1, vec![art], vec![], "")];
let tl = d.timeline_mut(0);
let mut masked = (*tl.layers[0]).clone();
masked.parent = Some(LayerId(321));
tl.layers = vec![Arc::new(mask), Arc::new(masked)];
}
d
}
/// Filters and soft masks together, as the page composes them: a soft mask over a filtered
/// symbol cuts what the filters made (the page masks the clip's layer after the filtered group
/// is composited into it), and a soft mask inside a filtered symbol shapes what the filters see
/// (the page's clip layer is inside the filtered layer). Both players' display lists agree (clip
/// modes, filters, groups), and the page's pixels, composed in that order from `filters.js` and
/// the mask artwork drawn as it looks (luminance or opacity becoming opacity, as canvas.js does),
/// equal the oracle's frame, in alpha and luminance mode, at two view scales.
#[test]
fn filters_and_soft_masks_compose_in_the_page_as_in_the_renderer() {
use anicraft_doc::MaskMode;
let mut js = filters_js();
let mut worst = 0.0f32;
for mode in [MaskMode::Alpha, MaskMode::Luminance] {
for inside in [false, true] {
let doc = soft_masked_doc(mode, inside);
let when = format!("{mode:?}, mask {}", if inside { "inside the filtered symbol" } else { "over it" });
compare(&doc, &[(vec![], vec![])]);
let m = movie(&doc, &HtmlOptions::default());
let exported = exported_filters(&m);
let dl = anicraft_doc::evaluate(&doc, 0);
assert_eq!((dl.clip_parents.len(), dl.clip_mode(0)), (1, mode), "{when}");
let filters = dl.groups.iter().find(|g| !g.filters.is_empty()).unwrap().filters.clone();
for scale in [1.0f32, 1.5] {
let (sw, sh) = ((64.0 * scale) as usize, (56.0 * scale) as usize);
let view = crate::View { transform: Affine::scale(scale, scale), width: sw as u32, height: sh as u32, background: Some(Rgba::WHITE) };
let (frame, _) = crate::render(&dl, &view).unwrap();
let (scene, _) = crate::prepare_scene(&dl, &view).unwrap();
let [l] = scene.layers.as_slice() else { panic!("{when}: one filtered layer") };
let (pm, _) = crate::render(&l.list, &l.view).unwrap();
let ((x0, y0, bw, bh), page, _) = page_and_oracle_filtered(&mut js, l, &pm.data, &filters, &exported, scale);
// A mask over the symbol: its artwork drawn as it looks on its own, read as the
// page reads it (canvas.js `maskEnd`).
let reveal: Option<Vec<f32>> = (!inside).then(|| {
let art = anicraft_doc::DisplayList { items: dl.items.iter().filter(|i| i.masks.is_some()).map(|i| anicraft_doc::DisplayItem { masks: None, clip: None, group: None, ..i.clone() }).collect(), clip_parents: Vec::new(), clip_modes: Vec::new(), groups: Vec::new() };
let (mp, _) = crate::render(&art, &crate::View { background: None, ..view }).unwrap();
mp.data.iter().map(|p| mode.reveal(*p)).collect()
});
for y in 0..sh {
for x in 0..sw {
let (lx, ly) = (x as i32 - x0, y as i32 - y0);
let mut p = if lx >= 0 && ly >= 0 && (lx as usize) < bw && (ly as usize) < bh { page[ly as usize * bw + lx as usize] } else { [0.0; 4] };
if let Some(r) = &reveal {
let k = r[y * sw + x];
p = [p[0] * k, p[1] * k, p[2] * k, p[3] * k];
}
// Over the white stage.
let out = [p[0] + 1.0 - p[3], p[1] + 1.0 - p[3], p[2] + 1.0 - p[3], 1.0];
let want = frame.data[y * sw + x];
for k in 0..4 {
let d = (out[k] - want[k]).abs();
worst = worst.max(d);
assert!(d < 3e-3, "{when} at ×{scale}, pixel ({x}, {y}) channel {k}: page {out:?}, renderer {want:?}");
}
}
}
}
}
}
eprintln!("largest difference from the renderer with soft masks: {worst:e}");
}
/// The page resolves each filter to the same whole box widths and pixel offsets as the renderer,
/// across angles, distances and view scales, including those that round at halves.
#[test]
fn the_pages_filters_resolve_like_the_renderers() {
use crate::filters::{FilterOp, resolve};
use anicraft_doc::{Filter, FilterSide};
let mut js = filters_js();
let mut cases = Vec::new();
for angle in [0.0f32, 30.0, 45.0, 60.0, 90.0, 135.0, 180.0, 210.0, 270.0, 300.0, 359.0, -45.0, 725.0] {
for distance in [0.0f32, 0.5, 1.0, 2.5, 3.0, 4.5, 7.0, -3.5] {
for (bx, by, q) in [(0.0f32, 0.0f32, 1u8), (2.5, 1.5, 2), (5.0, 9.0, 3), (0.3, 255.0, 1)] {
for scale in [1.0f32, 0.5, 1.25, 2.0, 3.0] {
cases.push((Filter::DropShadow { blur_x: bx, blur_y: by, strength: 1.0, quality: q, angle, distance, color: Rgba::BLACK, inner: false, knockout: false, hide_object: true }, scale));
cases.push((Filter::Bevel { blur_x: bx, blur_y: by, strength: 1.0, quality: q, angle, distance, shadow_color: Rgba::BLACK, highlight_color: Rgba::WHITE, side: FilterSide::Full, knockout: false }, scale));
}
}
}
}
let list: Vec<Value> = cases.iter().map(|(f, s)| json!([filter_json(f), s])).collect();
let got = js_json(&mut js, &format!("{}.map(function (c) {{ var o = AniCraftFilters.resolve(c[0], c[1]); return [o.blur.nx, o.blur.ny, o.blur.passes, o.dx, o.dy]; }})", Value::Array(list)));
for ((f, scale), g) in cases.iter().zip(got.as_array().unwrap()) {
let (blur, dx, dy) = match resolve(f, *scale) {
FilterOp::Shadow { blur, dx, dy, .. } | FilterOp::Bevel { blur, dx, dy, .. } => (blur, dx, dy),
other => panic!("{other:?}"),
};
assert_eq!(g, &json!([blur.nx, blur.ny, blur.passes, dx, dy]), "{f:?} at ×{scale}");
}
assert!(cases.len() > 4000);
// How far a group's filters reach: the renderer's margin.
for (m, scale) in [(3.0f32, 1.0f32), (7.25, 1.5), (0.0, 2.0)] {
assert_eq!(js_json(&mut js, &format!("AniCraftFilters.reach({m}, {scale})")), json!(((m * scale).ceil() + 2.0) as i64));
}
}
/// Subtract and Invert, composited by the page, follow the renderer's formula, in floats and
/// on the canvas's 8-bit pixels (within a step of rounding).
#[test]
fn the_page_subtracts_and_inverts_like_the_renderer() {
let mut js = filters_js();
let levels = [0.0f32, 0.2, 0.5, 0.8, 1.0];
let mut cases = Vec::new();
for &sa in &levels {
for &ba in &levels {
for &(cs, cb) in &[(0.9f32, 0.3f32), (0.1, 0.7), (0.5, 0.5), (1.0, 0.0)] {
cases.push(([cs * sa, (1.0 - cs) * sa, 0.4 * sa, sa], [cb * ba, 0.6 * ba, (1.0 - cb) * ba, ba]));
}
}
}
for (mode, key) in [(BlendMode::Subtract, "subtract"), (BlendMode::Invert, "invert")] {
let got = js_json(&mut js, &format!("{}.map(function (p) {{ return AniCraftFilters.blendPixel('{key}', p[0], p[1], [0, 0, 0, 0]); }})", json!(cases)));
for ((s, b), g) in cases.iter().zip(got.as_array().unwrap()) {
let want = crate::blend(mode, *s, *b);
for k in 0..4 {
assert!((g[k].as_f64().unwrap() as f32 - want[k]).abs() < 1e-5, "{key}: {s:?} over {b:?}: {g} vs {want:?}");
}
}
// 8-bit straight pixels, at a group alpha: the renderer's blend of the same colours.
let src: Vec<u8> = vec![230, 40, 100, 255, 10, 200, 90, 128, 255, 255, 255, 60, 0, 0, 0, 0];
let dst: Vec<u8> = vec![120, 180, 30, 255, 250, 20, 140, 255, 60, 60, 60, 200, 77, 88, 99, 255];
let alpha = 0.75f32;
let out = js_json(&mut js, &format!("(function () {{ var d = new Uint8ClampedArray({}); AniCraftFilters.blendImage(d, new Uint8ClampedArray({}), {alpha}, '{key}'); return Array.from(d); }})()", json!(dst), json!(src)));
let pre = |p: &[u8], k: f32| {
let a = f32::from(p[3]) / 255.0 * k;
[f32::from(p[0]) / 255.0 * a, f32::from(p[1]) / 255.0 * a, f32::from(p[2]) / 255.0 * a, a]
};
for i in 0..4 {
let (s, d) = (&src[i * 4..][..4], &dst[i * 4..][..4]);
let want = if s[3] == 0 { pre(d, 1.0) } else { crate::blend(mode, pre(s, alpha), pre(d, 1.0)) };
let a = want[3];
for k in 0..4 {
let v = if k == 3 { a } else if a > 0.0 { want[k] / a } else { 0.0 };
let g = out[i * 4 + k].as_f64().unwrap() as f32 / 255.0;
assert!((g - v).abs() <= 1.0 / 255.0 + 1e-6, "{key}, pixel {i}, channel {k}: {g} vs {v}");
}
}
}
}
/// Broken filter data (a page edited by hand, or a later format) is skipped, never thrown on.
#[test]
fn the_pages_filters_survive_broken_data() {
let mut js = filters_js();
let out = js_json(&mut js, "(function () { var b = new Float32Array([0.5, 0, 0, 0.5, 1, 1, 1, 1]); AniCraftFilters.apply(b, 2, 1, [null, 3, {k: 'sparkle'}, {k: 'adjust', m: [1]}, {k: 'blur', x: 'wide', y: NaN, q: -4}, {k: 'shadow'}, {k: 'bevel', st: 'x'}, {k: 'gglow', st: [[0.5]]}], NaN); AniCraftFilters.apply(b, 3, 1, [{k: 'blur', x: 2, y: 2, q: 1}], 1); AniCraftFilters.blendImage(new Uint8ClampedArray(4), new Uint8ClampedArray(8), NaN, 'invert'); return [Array.from(b).every(isFinite), AniCraftFilters.region(new Uint8ClampedArray(16), 2, 2, 5)]; })()");
assert_eq!(out, json!([true, null]));
}
#[test]
fn gradient_options_are_drawn_the_nearest_way_canvas_can() {
// ADR 0074: canvas gradients only pad, so reflect and repeat lay the ramp end to end.
let two = vec![GradientStop { offset: 0.0, color: Rgba::BLACK }, GradientStop { offset: 1.0, color: Rgba::WHITE }];
let (copies, st) = spread_stops(&two, anicraft_doc::Spread::Pad, false, false);
assert_eq!((copies, st.len()), (0, 2));
let (copies, st) = spread_stops(&two, anicraft_doc::Spread::Repeat, false, false);
let n = 2 * copies + 1;
assert!(copies > 0 && st.len() == 2 * n && st.len() <= 255);
// A linear ramp is the middle copy, forwards.
assert_eq!((st[2 * copies].offset, st[2 * copies].color), (copies as f32 / n as f32, Rgba::BLACK));
let (_, st) = spread_stops(&two, anicraft_doc::Spread::Reflect, false, false);
assert_eq!(st[2 * copies + 2].color, Rgba::WHITE, "the copy after it runs backwards");
// A radial one has no inside of its centre: the ramp comes first, then its copies.
let (_, out) = spread_stops(&two, anicraft_doc::Spread::Reflect, false, true);
assert_eq!((out[0].offset, out[0].color, out[2].color), (0.0, Rgba::BLACK, Rgba::WHITE));
// Linear RGB is sampled into stops: the midpoint is the linear-light grey (≈ 0.735).
let (_, lin) = spread_stops(&two, anicraft_doc::Spread::Pad, true, false);
let mid = lin.iter().find(|s| (s.offset - 0.5).abs() < 1e-6).expect("a stop at the middle");
assert!((mid.color.r - 0.735).abs() < 0.01, "{:?}", mid.color);
// Through the export: the radial's focal point and the reflected linear's longer span.
let mut lin_p = Paint::linear(Vec2::new(0.0, 0.0), Vec2::new(10.0, 0.0), two.clone());
if let Paint::Linear { spread, .. } = &mut lin_p {
*spread = anicraft_doc::Spread::Reflect;
}
let mut rad = Paint::radial(Vec2::new(50.0, 50.0), 20.0, two);
if let Paint::Radial { focal, .. } = &mut rad {
*focal = 0.5;
}
let mut doc = Document::default();
let shape = |id: u64, p: Paint| Arc::new(Element { id: ElementId(id), name: String::new(), transform: Affine::IDENTITY, color: ColorEffect::default(), kind: ElementKind::Shape(Shape::filled(Path::rect(0.0, 0.0, 100.0, 100.0), p)) });
{
let k = Arc::make_mut(&mut doc.timeline_mut(0).layers[0]).keyframe_mut(0).unwrap();
k.elements = vec![shape(80, lin_p), shape(81, rad)];
}
let m = movie(&doc, &HtmlOptions::default());
let paints = m.json["paints"].as_array().cloned().unwrap_or_default();
let l = paints.iter().find(|p| p.get("l").is_some()).expect("the linear gradient");
assert!(l["l"][0].as_f64().unwrap() < -9.0 && l["l"][2].as_f64().unwrap() > 19.0, "{l}");
let r = paints.iter().find(|p| p.get("r").is_some()).expect("the radial gradient");
assert_eq!(r["f"], json!([60, 50]));
assert_eq!(r["r"][2], json!(20));
}