Skip to main content

aylis_vector/
lottie.rs

1//! Player de Lottie (o JSON do Bodymovin/After Effects), desenhado pelo [`Canvas`] do aylis:
2//! o mesmo desenho no Skia, no Direct2D e no navegador.
3//!
4//! Cobre o que as animações de ícones e emojis usam (os emojis animados Noto do Google
5//! inteiros): camadas de forma, sólidas, nulas e pré-composições (com tempo remapeado),
6//! parentesco, transformações animadas (com curvas de velocidade e caminho de movimento),
7//! grupos, caminhos, elipses, retângulos, preenchimentos e contornos sólidos ou em
8//! gradiente (linear e radial), "Trim Paths", máscaras e "track mattes" (alfa e alfa
9//! invertido, como recorte pelo contorno da camada). Fica de fora: texto, imagens,
10//! efeitos, expressões e mattes de luminância (tratados como alfa).
11
12use 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// ---------------------------------------------------------------------------
20// Valores animados
21
22#[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    /// Valor final explícito (formato antigo); sem ele, vale o `s` da próxima chave.
33    e: Option<Vec<f32>>,
34    ease: Ease,
35    hold: bool,
36    /// Tangentes do caminho de movimento (posição).
37    to: Option<Vec<f32>>,
38    ti: Option<Vec<f32>>,
39}
40
41/// Uma propriedade: valor fixo ou chaves no tempo. Números e caminhos viram `Vec<f32>`
42/// (o caminho achatado: fechado, n, e por vértice v, i, o), então a interpolação é a mesma.
43#[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
53/// Número ou lista de números.
54fn 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
62/// Um caminho Bezier (`{i, o, v, c}`) achatado.
63fn 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            // Caminho de movimento: curva entre as posições.
138            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        // No formato antigo a última chave só marca o tempo: vale o fim da anterior.
153        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
171/// A curva de velocidade (cubic-bezier com pontos `o` e `i`) no progresso `x`.
172fn 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    // Acha t com x(t) = x (bisseção: robusta para qualquer curva) e devolve y(t).
178    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// ---------------------------------------------------------------------------
192// Modelo
193
194#[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    /// `a` soma (recorta para dentro), `s` subtrai (recorta para fora), `n` nenhuma.
364    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/// Uma animação Lottie lida.
445#[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    /// Lê o JSON do Lottie.
458    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    /// Tamanho da composição.
485    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    /// Primeiro e último quadro (o último fica de fora).
494    pub fn frames(&self) -> (f32, f32) {
495        (self.in_point, self.out_point)
496    }
497
498    /// Duração em segundos.
499    pub fn duration(&self) -> f32 {
500        (self.out_point - self.in_point).max(0.0) / self.frame_rate
501    }
502
503    /// O quadro no instante `seconds` (com `repeat`, volta ao começo; sem, para no fim).
504    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    /// Desenha o quadro `frame` ocupando `dest` (a composição inteira, `width` × `height`,
511    /// vai para `dest`; quem chama escolhe o encaixe).
512    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            // Track matte: a camada de cima (`td`) recorta esta pelo alfa dela.
531            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    /// O tempo dentro de uma pré-composição (as camadas dela contam do próprio começo).
553    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    /// Desenha uma camada (sem o matte dela). As propriedades usam o tempo da composição.
561    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    /// O contorno de uma camada (para usá-la como recorte): todas as formas, sem estilo.
601    #[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
627/// A camada aparece no quadro `t` (da composição dela).
628fn visible(layer: &Layer, t: f32) -> bool {
629    t >= layer.in_point && t < layer.out_point
630}
631
632/// A transformação da camada `i` com a dos pais (o parentesco não leva a opacidade).
633fn 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
642// ---------------------------------------------------------------------------
643// Formas
644
645/// O caminho de um valor achatado (`fechado, n, v i o...`).
646fn 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    // Começa em cima e vai no sentido horário (como o After Effects).
689    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
721/// As formas dos itens (e dos grupos dentro deles), já transformadas, com os "Trim Paths"
722/// aplicados às formas que vêm antes deles.
723fn 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
792/// Desenha um grupo: de baixo para cima (o primeiro item fica por cima, como no After
793/// Effects); cada estilo pinta as formas que vêm antes dele no grupo.
794fn 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}