1use std::collections::HashMap;
13
14use aylis_core::{Brush, Canvas, Color, GradientStop, LineCap, LineJoin, Path, PointF, RectF, Stroke};
15use serde_json::Value;
16
17use crate::geom::{Affine, dist, has_figures, rect_path, trim};
18
19#[derive(Clone, Copy, Debug, Default)]
23struct Ease {
24 o: (f32, f32),
25 i: (f32, f32),
26}
27
28#[derive(Clone, Debug)]
29struct Key {
30 t: f32,
31 s: Vec<f32>,
32 e: Option<Vec<f32>>,
34 ease: Ease,
35 hold: bool,
36 to: Option<Vec<f32>>,
38 ti: Option<Vec<f32>>,
39}
40
41#[derive(Clone, Debug)]
44enum Prop {
45 Static(Vec<f32>),
46 Anim(Vec<Key>),
47}
48
49fn num(v: &Value) -> Option<f32> {
50 v.as_f64().map(|n| n as f32)
51}
52
53fn numbers(v: &Value) -> Option<Vec<f32>> {
55 match v {
56 Value::Number(_) => Some(vec![num(v)?]),
57 Value::Array(a) => a.iter().map(num).collect(),
58 _ => None,
59 }
60}
61
62fn bezier(v: &Value) -> Option<Vec<f32>> {
64 let v = if let Value::Array(a) = v { a.first()? } else { v };
65 let pts = |key: &str| -> Option<Vec<[f32; 2]>> {
66 v.get(key)?.as_array()?.iter().map(|p| Some([num(p.get(0)?)?, num(p.get(1)?)?])).collect()
67 };
68 let (vs, is, os) = (pts("v")?, pts("i").unwrap_or_default(), pts("o").unwrap_or_default());
69 let closed = v.get("c").and_then(Value::as_bool).unwrap_or(false);
70 let mut out = vec![if closed { 1.0 } else { 0.0 }, vs.len() as f32];
71 for (k, p) in vs.iter().enumerate() {
72 let i = is.get(k).copied().unwrap_or([0.0, 0.0]);
73 let o = os.get(k).copied().unwrap_or([0.0, 0.0]);
74 out.extend_from_slice(&[p[0], p[1], i[0], i[1], o[0], o[1]]);
75 }
76 Some(out)
77}
78
79fn ease_part(v: Option<&Value>) -> Option<(f32, f32)> {
80 let v = v?;
81 let first = |k: &str| v.get(k).and_then(|x| if let Value::Array(a) = x { a.first().and_then(num) } else { num(x) });
82 Some((first("x")?, first("y")?))
83}
84
85impl Prop {
86 fn parse(v: Option<&Value>, conv: fn(&Value) -> Option<Vec<f32>>, default: &[f32]) -> Prop {
87 let Some(v) = v else { return Prop::Static(default.to_vec()) };
88 let k = v.get("k").unwrap_or(v);
89 if let Value::Array(items) = k {
90 if items.first().is_some_and(|f| f.get("t").is_some()) {
91 let keys: Vec<Key> = items
92 .iter()
93 .filter_map(|f| {
94 Some(Key {
95 t: num(f.get("t")?)?,
96 s: f.get("s").and_then(conv).unwrap_or_default(),
97 e: f.get("e").and_then(conv),
98 ease: Ease {
99 o: ease_part(f.get("o")).unwrap_or((0.0, 0.0)),
100 i: ease_part(f.get("i")).unwrap_or((1.0, 1.0)),
101 },
102 hold: f.get("h").and_then(Value::as_i64) == Some(1),
103 to: f.get("to").and_then(numbers),
104 ti: f.get("ti").and_then(numbers),
105 })
106 })
107 .collect();
108 if !keys.is_empty() {
109 return Prop::Anim(keys);
110 }
111 }
112 }
113 Prop::Static(conv(k).unwrap_or_else(|| default.to_vec()))
114 }
115
116 fn at(&self, t: f32) -> Vec<f32> {
117 let keys = match self {
118 Prop::Static(v) => return v.clone(),
119 Prop::Anim(keys) => keys,
120 };
121 let first = &keys[0];
122 if t <= first.t || keys.len() == 1 {
123 return if first.s.is_empty() { first.e.clone().unwrap_or_default() } else { first.s.clone() };
124 }
125 for w in keys.windows(2) {
126 let (k, next) = (&w[0], &w[1]);
127 if t >= next.t {
128 continue;
129 }
130 let start = &k.s;
131 let end = k.e.as_ref().unwrap_or(&next.s);
132 if k.hold || end.is_empty() {
133 return start.clone();
134 }
135 let span = (next.t - k.t).max(1e-6);
136 let p = cubic_ease(k.ease, ((t - k.t) / span).clamp(0.0, 1.0));
137 if let (Some(to), Some(ti)) = (&k.to, &k.ti) {
139 if start.len() >= 2 && end.len() >= 2 && to.len() >= 2 && ti.len() >= 2 && (to.iter().any(|v| *v != 0.0) || ti.iter().any(|v| *v != 0.0)) {
140 let c = |i: usize| bez(start[i], start[i] + to[i], end[i] + ti[i], end[i], p);
141 let mut out: Vec<f32> = (0..start.len().min(end.len())).map(|i| if i < 2 { c(i) } else { start[i] + (end[i] - start[i]) * p }).collect();
142 out.truncate(start.len().min(end.len()));
143 return out;
144 }
145 }
146 return start.iter().zip(end.iter()).map(|(a, b)| a + (b - a) * p).collect();
147 }
148 let last = &keys[keys.len() - 1];
149 if !last.s.is_empty() {
150 return last.s.clone();
151 }
152 keys.iter().rev().find_map(|k| k.e.clone().or_else(|| (!k.s.is_empty()).then(|| k.s.clone()))).unwrap_or_default()
154 }
155
156 fn scalar(&self, t: f32) -> f32 {
157 self.at(t).first().copied().unwrap_or(0.0)
158 }
159
160 fn point(&self, t: f32) -> PointF {
161 let v = self.at(t);
162 PointF::new(v.first().copied().unwrap_or(0.0), v.get(1).copied().unwrap_or(0.0))
163 }
164}
165
166fn bez(a: f32, b: f32, c: f32, d: f32, t: f32) -> f32 {
167 let u = 1.0 - t;
168 u * u * u * a + 3.0 * u * u * t * b + 3.0 * u * t * t * c + t * t * t * d
169}
170
171fn cubic_ease(e: Ease, x: f32) -> f32 {
173 let (x1, y1, x2, y2) = (e.o.0, e.o.1, e.i.0, e.i.1);
174 if (x1 - y1).abs() < 1e-6 && (x2 - y2).abs() < 1e-6 {
175 return x;
176 }
177 let (mut lo, mut hi) = (0.0f32, 1.0f32);
179 let mut t = x;
180 for _ in 0..24 {
181 let xt = bez(0.0, x1, x2, 1.0, t);
182 if (xt - x).abs() < 1e-5 {
183 break;
184 }
185 if xt < x { lo = t } else { hi = t }
186 t = (lo + hi) / 2.0;
187 }
188 bez(0.0, y1, y2, 1.0, t)
189}
190
191#[derive(Clone, Debug)]
195enum Position {
196 Joined(Prop),
197 Split(Prop, Prop),
198}
199
200#[derive(Clone, Debug)]
201struct Transform {
202 anchor: Prop,
203 position: Position,
204 scale: Prop,
205 rotation: Prop,
206 opacity: Prop,
207 skew: Prop,
208 skew_axis: Prop,
209}
210
211impl Transform {
212 fn parse(v: Option<&Value>) -> Transform {
213 let get = |k: &str| v.and_then(|v| v.get(k));
214 let position = match get("p") {
215 Some(p) if p.get("s").and_then(Value::as_bool) == Some(true) => {
216 Position::Split(Prop::parse(p.get("x"), numbers, &[0.0]), Prop::parse(p.get("y"), numbers, &[0.0]))
217 }
218 p => Position::Joined(Prop::parse(p, numbers, &[0.0, 0.0])),
219 };
220 Transform {
221 anchor: Prop::parse(get("a"), numbers, &[0.0, 0.0]),
222 position,
223 scale: Prop::parse(get("s"), numbers, &[100.0, 100.0]),
224 rotation: Prop::parse(get("r").or_else(|| get("rz")), numbers, &[0.0]),
225 opacity: Prop::parse(get("o"), numbers, &[100.0]),
226 skew: Prop::parse(get("sk"), numbers, &[0.0]),
227 skew_axis: Prop::parse(get("sa"), numbers, &[0.0]),
228 }
229 }
230
231 fn matrix(&self, t: f32) -> Affine {
232 let a = self.anchor.point(t);
233 let p = match &self.position {
234 Position::Joined(p) => p.point(t),
235 Position::Split(x, y) => PointF::new(x.scalar(t), y.scalar(t)),
236 };
237 let s = self.scale.at(t);
238 let (sx, sy) = (s.first().copied().unwrap_or(100.0) / 100.0, s.get(1).copied().unwrap_or(100.0) / 100.0);
239 let mut m = Affine::translate(p.x, p.y).then(Affine::rotate(self.rotation.scalar(t)));
240 let sk = self.skew.scalar(t);
241 if sk != 0.0 {
242 let axis = self.skew_axis.scalar(t);
243 m = m.then(Affine::rotate(axis)).then(Affine::skew_x(-sk)).then(Affine::rotate(-axis));
244 }
245 m.then(Affine::scale(sx, sy)).then(Affine::translate(-a.x, -a.y))
246 }
247
248 fn opacity(&self, t: f32) -> f32 {
249 (self.opacity.scalar(t) / 100.0).clamp(0.0, 1.0)
250 }
251}
252
253#[derive(Clone, Debug)]
254struct Gradient {
255 radial: bool,
256 start: Prop,
257 end: Prop,
258 count: usize,
259 stops: Prop,
260}
261
262#[derive(Clone, Debug)]
263enum Paint {
264 Solid(Prop),
265 Gradient(Gradient),
266}
267
268#[derive(Clone, Debug)]
269struct StrokeStyle {
270 width: Prop,
271 cap: LineCap,
272 join: LineJoin,
273}
274
275#[derive(Clone, Debug)]
276enum Item {
277 Group { items: Vec<Item>, transform: Option<Transform> },
278 Shape { path: Prop, reversed: bool },
279 Ellipse { center: Prop, size: Prop, reversed: bool },
280 Rect { center: Prop, size: Prop, radius: Prop, reversed: bool },
281 Fill { paint: Paint, opacity: Prop, even_odd: bool },
282 Stroke { paint: Paint, opacity: Prop, style: StrokeStyle },
283 Trim { start: Prop, end: Prop, offset: Prop },
284}
285
286fn parse_items(list: Option<&Value>) -> Vec<Item> {
287 let Some(Value::Array(list)) = list else { return Vec::new() };
288 list.iter().filter(|s| s.get("hd").and_then(Value::as_bool) != Some(true)).filter_map(parse_item).collect()
289}
290
291fn parse_paint(s: &Value, gradient: bool) -> Paint {
292 if gradient {
293 let g = s.get("g");
294 Paint::Gradient(Gradient {
295 radial: s.get("t").and_then(Value::as_i64) == Some(2),
296 start: Prop::parse(s.get("s"), numbers, &[0.0, 0.0]),
297 end: Prop::parse(s.get("e"), numbers, &[0.0, 0.0]),
298 count: g.and_then(|g| g.get("p")).and_then(Value::as_u64).unwrap_or(0) as usize,
299 stops: Prop::parse(g.and_then(|g| g.get("k")), numbers, &[]),
300 })
301 } else {
302 Paint::Solid(Prop::parse(s.get("c"), numbers, &[0.0, 0.0, 0.0, 1.0]))
303 }
304}
305
306fn parse_item(s: &Value) -> Option<Item> {
307 let reversed = s.get("d").and_then(Value::as_i64) == Some(3);
308 Some(match s.get("ty")?.as_str()? {
309 "gr" => {
310 let list = s.get("it").and_then(Value::as_array);
311 let transform = list.and_then(|l| l.iter().find(|i| i.get("ty").and_then(Value::as_str) == Some("tr"))).map(|tr| Transform::parse(Some(tr)));
312 Item::Group { items: parse_items(s.get("it")), transform }
313 }
314 "sh" => Item::Shape { path: Prop::parse(s.get("ks"), bezier, &[]), reversed },
315 "el" => Item::Ellipse { center: Prop::parse(s.get("p"), numbers, &[0.0, 0.0]), size: Prop::parse(s.get("s"), numbers, &[0.0, 0.0]), reversed },
316 "rc" => Item::Rect {
317 center: Prop::parse(s.get("p"), numbers, &[0.0, 0.0]),
318 size: Prop::parse(s.get("s"), numbers, &[0.0, 0.0]),
319 radius: Prop::parse(s.get("r"), numbers, &[0.0]),
320 reversed,
321 },
322 ty @ ("fl" | "gf") => Item::Fill {
323 paint: parse_paint(s, ty == "gf"),
324 opacity: Prop::parse(s.get("o"), numbers, &[100.0]),
325 even_odd: s.get("r").and_then(Value::as_i64) == Some(2),
326 },
327 ty @ ("st" | "gs") => Item::Stroke {
328 paint: parse_paint(s, ty == "gs"),
329 opacity: Prop::parse(s.get("o"), numbers, &[100.0]),
330 style: StrokeStyle {
331 width: Prop::parse(s.get("w"), numbers, &[1.0]),
332 cap: match s.get("lc").and_then(Value::as_i64) {
333 Some(2) => LineCap::Round,
334 Some(3) => LineCap::Square,
335 _ => LineCap::Butt,
336 },
337 join: match s.get("lj").and_then(Value::as_i64) {
338 Some(2) => LineJoin::Round,
339 Some(3) => LineJoin::Bevel,
340 _ => LineJoin::Miter,
341 },
342 },
343 },
344 "tm" => Item::Trim {
345 start: Prop::parse(s.get("s"), numbers, &[0.0]),
346 end: Prop::parse(s.get("e"), numbers, &[100.0]),
347 offset: Prop::parse(s.get("o"), numbers, &[0.0]),
348 },
349 _ => return None,
350 })
351}
352
353#[derive(Clone, Debug, PartialEq, Eq)]
354enum Matte {
355 None,
356 Alpha,
357 Inverted,
358}
359
360#[derive(Clone, Debug)]
361struct Mask {
362 path: Prop,
363 mode: char,
365 inverted: bool,
366}
367
368#[derive(Clone, Debug)]
369enum LayerKind {
370 Shapes(Vec<Item>),
371 Precomp { id: String, size: (f32, f32), remap: Option<Prop> },
372 Solid { color: Color, size: (f32, f32) },
373 Null,
374}
375
376#[derive(Clone, Debug)]
377struct Layer {
378 index: Option<i64>,
379 parent: Option<i64>,
380 kind: LayerKind,
381 in_point: f32,
382 out_point: f32,
383 start: f32,
384 stretch: f32,
385 transform: Transform,
386 matte: Matte,
387 is_matte: bool,
388 masks: Vec<Mask>,
389}
390
391fn parse_layers(v: Option<&Value>) -> Vec<Layer> {
392 let Some(Value::Array(list)) = v else { return Vec::new() };
393 list.iter().filter(|l| l.get("hd").and_then(Value::as_bool) != Some(true)).filter_map(parse_layer).collect()
394}
395
396fn parse_layer(l: &Value) -> Option<Layer> {
397 let f = |k: &str, d: f32| l.get(k).and_then(num).unwrap_or(d);
398 let kind = match l.get("ty")?.as_i64()? {
399 4 => LayerKind::Shapes(parse_items(l.get("shapes"))),
400 0 => LayerKind::Precomp {
401 id: l.get("refId")?.as_str()?.to_string(),
402 size: (f("w", 0.0), f("h", 0.0)),
403 remap: l.get("tm").map(|tm| Prop::parse(Some(tm), numbers, &[0.0])),
404 },
405 1 => LayerKind::Solid {
406 color: l.get("sc").and_then(Value::as_str).and_then(Color::from_hex).unwrap_or(Color::BLACK),
407 size: (f("sw", 0.0), f("sh", 0.0)),
408 },
409 3 => LayerKind::Null,
410 _ => return None,
411 };
412 let masks = l
413 .get("masksProperties")
414 .and_then(Value::as_array)
415 .map(|list| {
416 list.iter()
417 .map(|m| Mask {
418 path: Prop::parse(m.get("pt"), bezier, &[]),
419 mode: m.get("mode").and_then(Value::as_str).and_then(|s| s.chars().next()).unwrap_or('a'),
420 inverted: m.get("inv").and_then(Value::as_bool).unwrap_or(false),
421 })
422 .collect()
423 })
424 .unwrap_or_default();
425 Some(Layer {
426 index: l.get("ind").and_then(Value::as_i64),
427 parent: l.get("parent").and_then(Value::as_i64),
428 kind,
429 in_point: f("ip", 0.0),
430 out_point: f("op", f32::MAX),
431 start: f("st", 0.0),
432 stretch: f("sr", 1.0).max(1e-3),
433 transform: Transform::parse(l.get("ks")),
434 matte: match l.get("tt").and_then(Value::as_i64) {
435 Some(2) | Some(4) => Matte::Inverted,
436 Some(_) => Matte::Alpha,
437 None => Matte::None,
438 },
439 is_matte: l.get("td").and_then(Value::as_i64).is_some_and(|v| v != 0),
440 masks,
441 })
442}
443
444#[derive(Clone, Debug)]
446pub struct Animation {
447 width: f32,
448 height: f32,
449 frame_rate: f32,
450 in_point: f32,
451 out_point: f32,
452 layers: Vec<Layer>,
453 assets: HashMap<String, Vec<Layer>>,
454}
455
456impl Animation {
457 pub fn parse(json: &[u8]) -> Result<Animation, String> {
459 let v: Value = serde_json::from_slice(json).map_err(|e| format!("JSON inválido: {e}"))?;
460 if v.get("layers").and_then(Value::as_array).is_none() {
461 return Err("não é uma animação Lottie (sem \"layers\")".into());
462 }
463 let f = |k: &str, d: f32| v.get(k).and_then(num).unwrap_or(d);
464 let assets = v
465 .get("assets")
466 .and_then(Value::as_array)
467 .map(|list| {
468 list.iter()
469 .filter_map(|a| Some((a.get("id")?.as_str()?.to_string(), parse_layers(Some(a.get("layers")?)))))
470 .collect()
471 })
472 .unwrap_or_default();
473 Ok(Animation {
474 width: f("w", 100.0),
475 height: f("h", 100.0),
476 frame_rate: f("fr", 30.0).max(1.0),
477 in_point: f("ip", 0.0),
478 out_point: f("op", 60.0),
479 layers: parse_layers(v.get("layers")),
480 assets,
481 })
482 }
483
484 pub fn size(&self) -> (f32, f32) {
486 (self.width, self.height)
487 }
488
489 pub fn frame_rate(&self) -> f32 {
490 self.frame_rate
491 }
492
493 pub fn frames(&self) -> (f32, f32) {
495 (self.in_point, self.out_point)
496 }
497
498 pub fn duration(&self) -> f32 {
500 (self.out_point - self.in_point).max(0.0) / self.frame_rate
501 }
502
503 pub fn frame_at(&self, seconds: f32, repeat: bool) -> f32 {
505 let total = (self.out_point - self.in_point).max(1e-3);
506 let f = seconds * self.frame_rate;
507 if repeat { self.in_point + f.rem_euclid(total) } else { self.in_point + f.clamp(0.0, total - 1e-3) }
508 }
509
510 pub fn render(&self, canvas: &mut dyn Canvas, frame: f32, dest: RectF) {
513 let m = Affine::rect_to_rect(RectF::new(0.0, 0.0, self.width, self.height), dest);
514 self.render_comp(canvas, &self.layers, frame, m, 0);
515 }
516
517 fn render_comp(&self, canvas: &mut dyn Canvas, layers: &[Layer], t: f32, base: Affine, depth: usize) {
518 if depth > 8 {
519 return;
520 }
521 for i in (0..layers.len()).rev() {
522 let layer = &layers[i];
523 if layer.is_matte || !visible(layer, t) {
524 continue;
525 }
526 if layer.matte == Matte::None || i == 0 {
527 self.draw_layer(canvas, layers, i, t, base, depth);
528 continue;
529 }
530 let inverse = layer.matte == Matte::Inverted;
532 canvas.save();
533 if canvas.begin_masked(inverse) {
534 self.draw_layer(canvas, layers, i, t, base, depth);
535 canvas.begin_mask();
536 if visible(&layers[i - 1], t) {
537 self.draw_layer(canvas, layers, i - 1, t, base, depth);
538 }
539 canvas.end_mask();
540 } else {
541 let mut outline = Path::new();
542 if visible(&layers[i - 1], t) {
543 self.outline(&layers[i - 1], layers, i - 1, t, base, &mut outline, depth);
544 }
545 canvas.clip_path(&outline, inverse);
546 self.draw_layer(canvas, layers, i, t, base, depth);
547 }
548 canvas.restore();
549 }
550 }
551
552 fn child_time(&self, layer: &Layer, remap: &Option<Prop>, t: f32) -> f32 {
554 match remap {
555 Some(tm) => tm.scalar(t) * self.frame_rate,
556 None => (t - layer.start) / layer.stretch,
557 }
558 }
559
560 fn draw_layer(&self, canvas: &mut dyn Canvas, layers: &[Layer], i: usize, t: f32, base: Affine, depth: usize) {
562 let layer = &layers[i];
563 let opacity = layer.transform.opacity(t);
564 if opacity <= 0.001 || matches!(layer.kind, LayerKind::Null) {
565 return;
566 }
567 let m = base.then(layer_matrix(layers, i, t, 0));
568 canvas.save();
569 for mask in &layer.masks {
570 if mask.mode == 'n' {
571 continue;
572 }
573 let path = m.path(&shape_path(&mask.path.at(t), false));
574 canvas.clip_path(&path, (mask.mode == 's') != mask.inverted);
575 }
576 if opacity < 0.999 {
577 canvas.save_layer(opacity);
578 }
579 match &layer.kind {
580 LayerKind::Shapes(items) => draw_group(canvas, items, m, 1.0, t),
581 LayerKind::Precomp { id, size, remap } => {
582 if let Some(inner) = self.assets.get(id) {
583 if size.0 > 0.0 && size.1 > 0.0 {
584 canvas.clip_path(&rect_path(&m, RectF::new(0.0, 0.0, size.0, size.1)), false);
585 }
586 self.render_comp(canvas, inner, self.child_time(layer, remap, t), m, depth + 1);
587 }
588 }
589 LayerKind::Solid { color, size } => {
590 canvas.fill_path(&rect_path(&m, RectF::new(0.0, 0.0, size.0, size.1)), &Brush::Solid(*color));
591 }
592 LayerKind::Null => {}
593 }
594 if opacity < 0.999 {
595 canvas.restore();
596 }
597 canvas.restore();
598 }
599
600 #[allow(clippy::too_many_arguments)]
602 fn outline(&self, layer: &Layer, layers: &[Layer], i: usize, t: f32, base: Affine, out: &mut Path, depth: usize) {
603 if depth > 8 {
604 return;
605 }
606 let m = base.then(layer_matrix(layers, i, t, 0));
607 match &layer.kind {
608 LayerKind::Shapes(items) => collect(items, m, t, out),
609 LayerKind::Solid { size, .. } => {
610 out.append(&rect_path(&m, RectF::new(0.0, 0.0, size.0, size.1)));
611 }
612 LayerKind::Precomp { id, remap, .. } => {
613 if let Some(inner) = self.assets.get(id) {
614 let child_t = self.child_time(layer, remap, t);
615 for (j, l) in inner.iter().enumerate() {
616 if !l.is_matte && child_t >= l.in_point && child_t < l.out_point {
617 self.outline(l, inner, j, child_t, m, out, depth + 1);
618 }
619 }
620 }
621 }
622 LayerKind::Null => {}
623 }
624 }
625}
626
627fn visible(layer: &Layer, t: f32) -> bool {
629 t >= layer.in_point && t < layer.out_point
630}
631
632fn layer_matrix(layers: &[Layer], i: usize, t: f32, depth: usize) -> Affine {
634 let layer = &layers[i];
635 let local = layer.transform.matrix(t);
636 match layer.parent.and_then(|p| layers.iter().position(|l| l.index == Some(p))) {
637 Some(parent) if depth < 16 && parent != i => layer_matrix(layers, parent, t, depth + 1).then(local),
638 _ => local,
639 }
640}
641
642fn shape_path(v: &[f32], reversed: bool) -> Path {
647 let mut path = Path::new();
648 if v.len() < 2 {
649 return path;
650 }
651 let closed = v[0] > 0.5;
652 let n = (v[1].max(0.0) as usize).min((v.len() - 2) / 6);
653 if n == 0 {
654 return path;
655 }
656 let mut verts: Vec<[PointF; 3]> = (0..n)
657 .map(|k| {
658 let b = 2 + k * 6;
659 let p = PointF::new(v[b], v[b + 1]);
660 [p, PointF::new(p.x + v[b + 2], p.y + v[b + 3]), PointF::new(p.x + v[b + 4], p.y + v[b + 5])]
661 })
662 .collect();
663 if reversed {
664 verts.reverse();
665 for vt in &mut verts {
666 vt.swap(1, 2);
667 }
668 }
669 path.move_to(verts[0][0].x, verts[0][0].y);
670 let seg = |path: &mut Path, a: &[PointF; 3], b: &[PointF; 3]| {
671 path.cubic_to(a[2].x, a[2].y, b[1].x, b[1].y, b[0].x, b[0].y);
672 };
673 for k in 1..n {
674 seg(&mut path, &verts[k - 1], &verts[k]);
675 }
676 if closed {
677 seg(&mut path, &verts[n - 1], &verts[0]);
678 path.close();
679 }
680 path
681}
682
683const KAPPA: f32 = 0.552_284_8;
684
685fn ellipse_path(c: PointF, size: PointF, reversed: bool) -> Path {
686 let (rx, ry) = (size.x / 2.0, size.y / 2.0);
687 let (kx, ky) = (rx * KAPPA, ry * KAPPA);
688 let v = [
690 1.0, 4.0, c.x, c.y - ry, -kx, 0.0, kx, 0.0, c.x + rx, c.y, 0.0, -ky, 0.0, ky, c.x, c.y + ry, kx, 0.0, -kx, 0.0, c.x - rx, c.y, 0.0, ky,
691 0.0, -ky,
692 ];
693 shape_path(&v, reversed)
694}
695
696fn rect_shape(c: PointF, size: PointF, radius: f32, reversed: bool) -> Path {
697 let (w, h) = (size.x / 2.0, size.y / 2.0);
698 let r = radius.min(w).min(h).max(0.0);
699 let (l, t, rt, b) = (c.x - w, c.y - h, c.x + w, c.y + h);
700 let v: Vec<f32> = if r <= 0.0 {
701 vec![1.0, 4.0, rt, t, 0.0, 0.0, 0.0, 0.0, rt, b, 0.0, 0.0, 0.0, 0.0, l, b, 0.0, 0.0, 0.0, 0.0, l, t, 0.0, 0.0, 0.0, 0.0]
702 } else {
703 let k = r * KAPPA;
704 vec![
705 1.0, 8.0, rt, t + r, 0.0, -k, 0.0, 0.0, rt, b - r, 0.0, 0.0, 0.0, k, rt - r, b, k, 0.0, 0.0, 0.0, l + r, b, 0.0, 0.0, -k, 0.0, l,
706 b - r, 0.0, k, 0.0, 0.0, l, t + r, 0.0, 0.0, 0.0, -k, l + r, t, -k, 0.0, 0.0, 0.0, rt - r, t, 0.0, 0.0, k, 0.0,
707 ]
708 };
709 shape_path(&v, reversed)
710}
711
712fn geometry(item: &Item, t: f32) -> Option<Path> {
713 Some(match item {
714 Item::Shape { path, reversed } => shape_path(&path.at(t), *reversed),
715 Item::Ellipse { center, size, reversed } => ellipse_path(center.point(t), size.point(t), *reversed),
716 Item::Rect { center, size, radius, reversed } => rect_shape(center.point(t), size.point(t), radius.scalar(t), *reversed),
717 _ => return None,
718 })
719}
720
721fn collect(items: &[Item], m: Affine, t: f32, out: &mut Path) {
724 let mut local = Path::new();
725 for item in items {
726 match item {
727 Item::Group { items, transform } => {
728 let gm = transform.as_ref().map_or(m, |tr| m.then(tr.matrix(t)));
729 collect(items, gm, t, &mut local);
730 }
731 Item::Trim { start, end, offset } => {
732 let (s, e, o) = (start.scalar(t) / 100.0, end.scalar(t) / 100.0, offset.scalar(t) / 360.0);
733 local = trim(&local, s, e, o);
734 }
735 other => {
736 if let Some(p) = geometry(other, t) {
737 local.append(&m.path(&p));
738 }
739 }
740 }
741 }
742 out.append(&local);
743}
744
745fn color_of(v: &[f32], opacity: f32) -> Color {
746 let c = |i: usize| (v.get(i).copied().unwrap_or(0.0).clamp(0.0, 1.0) * 255.0).round() as u8;
747 let a = v.get(3).copied().unwrap_or(1.0).clamp(0.0, 1.0) * opacity.clamp(0.0, 1.0);
748 Color::rgba(c(0), c(1), c(2), (a * 255.0).round() as u8)
749}
750
751fn brush_of(paint: &Paint, m: Affine, t: f32, opacity: f32) -> Brush {
752 match paint {
753 Paint::Solid(c) => Brush::Solid(color_of(&c.at(t), opacity)),
754 Paint::Gradient(g) => {
755 let raw = g.stops.at(t);
756 let count = g.count.min(raw.len() / 4);
757 let alphas: Vec<(f32, f32)> = raw[count * 4..].chunks_exact(2).map(|c| (c[0], c[1])).collect();
758 let alpha_at = |x: f32| -> f32 {
759 if alphas.is_empty() {
760 return 1.0;
761 }
762 if x <= alphas[0].0 {
763 return alphas[0].1;
764 }
765 for w in alphas.windows(2) {
766 if x <= w[1].0 {
767 let span = (w[1].0 - w[0].0).max(1e-6);
768 return w[0].1 + (w[1].1 - w[0].1) * (x - w[0].0) / span;
769 }
770 }
771 alphas[alphas.len() - 1].1
772 };
773 let stops: Vec<GradientStop> = (0..count)
774 .map(|k| {
775 let s = &raw[k * 4..k * 4 + 4];
776 GradientStop::new(s[0], color_of(&[s[1], s[2], s[3], alpha_at(s[0])], opacity))
777 })
778 .collect();
779 if stops.is_empty() {
780 return Brush::Solid(Color::TRANSPARENT);
781 }
782 let (s, e) = (g.start.point(t), g.end.point(t));
783 if g.radial {
784 Brush::Radial { center: m.apply(s), radius: (dist(s, e) * m.scale_factor()).max(0.01), stops }
785 } else {
786 Brush::Linear { start: m.apply(s), end: m.apply(e), stops }
787 }
788 }
789 }
790}
791
792fn draw_group(canvas: &mut dyn Canvas, items: &[Item], m: Affine, opacity: f32, t: f32) {
795 for idx in (0..items.len()).rev() {
796 match &items[idx] {
797 Item::Group { items: inner, transform } => {
798 let (gm, go) = match transform {
799 Some(tr) => (m.then(tr.matrix(t)), opacity * tr.opacity(t)),
800 None => (m, opacity),
801 };
802 if go > 0.001 {
803 draw_group(canvas, inner, gm, go, t);
804 }
805 }
806 Item::Fill { paint, opacity: o, even_odd } => {
807 let mut path = Path::new();
808 collect(&items[..idx], m, t, &mut path);
809 if has_figures(&path) {
810 path.even_odd = *even_odd;
811 canvas.fill_path(&path, &brush_of(paint, m, t, opacity * o.scalar(t) / 100.0));
812 }
813 }
814 Item::Stroke { paint, opacity: o, style } => {
815 let width = style.width.scalar(t) * m.scale_factor();
816 if width <= 0.0 {
817 continue;
818 }
819 let mut path = Path::new();
820 collect(&items[..idx], m, t, &mut path);
821 if has_figures(&path) {
822 let mut stroke = Stroke::new(brush_of(paint, m, t, opacity * o.scalar(t) / 100.0), width);
823 stroke.cap = style.cap;
824 stroke.join = style.join;
825 canvas.stroke_path(&path, &stroke);
826 }
827 }
828 _ => {}
829 }
830 }
831}
832
833#[cfg(test)]
834mod tests {
835 use super::*;
836
837 #[test]
838 fn keyframes_ease_and_hold() {
839 let v: Value = serde_json::from_str(
840 r#"{"a":1,"k":[{"t":0,"s":[0],"o":{"x":[0.333],"y":[0]},"i":{"x":[0.667],"y":[1]}},{"t":10,"s":[100],"h":1},{"t":20,"s":[50]}]}"#,
841 )
842 .unwrap();
843 let p = Prop::parse(Some(&v), numbers, &[0.0]);
844 assert_eq!(p.scalar(-5.0), 0.0);
845 assert!((p.scalar(5.0) - 50.0).abs() < 1.0, "meio da curva simétrica: {}", p.scalar(5.0));
846 assert!(p.scalar(2.0) < 20.0, "começa devagar");
847 assert_eq!(p.scalar(15.0), 100.0, "segura");
848 assert_eq!(p.scalar(30.0), 50.0);
849 }
850
851 #[test]
852 fn a_shape_path_is_rebuilt_from_vertices() {
853 let v = bezier(&serde_json::json!({"c": true, "v": [[0,0],[10,0],[10,10]], "i": [[0,0],[0,0],[0,0]], "o": [[0,0],[0,0],[0,0]]})).unwrap();
854 let p = shape_path(&v, false);
855 let b = p.bounds();
856 assert_eq!((b.width, b.height), (10.0, 10.0));
857 assert!(matches!(p.cmds.last(), Some(aylis_core::PathCmd::Close)));
858 }
859}