GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
use super::*;
use filmcraft_project::graphic::{new_shape_layer, new_text_layer};
use filmcraft_project::{ParamValue, find_effect};

fn set(e: &mut EffectInstance, k: &str, v: ParamValue) {
    e.params.get_mut(k).unwrap_or_else(|| panic!("{k}")).value = v;
}

/// A 5 s graphic clip holding `layers` (canvas 400×300 at 25 fps).
fn graphic_item(layers: Vec<EffectInstance>) -> TrackItem {
    let mut p = filmcraft_project::Project::new("t");
    let rate = filmcraft_time::FrameRate::FPS_25;
    let g = p.add_item("G", filmcraft_project::Label::Rose, filmcraft_project::ItemKind::Graphic { width: 400, height: 300, rate }, None);
    let mut it = p
        .make_track_item(g, filmcraft_project::TrackKind::Video, Tick::ZERO, filmcraft_time::TimeRange::new(Tick::ZERO, Tick::from_seconds_f64(5.0)), rate)
        .unwrap();
    it.effects.extend(layers);
    it
}

fn ink_box(img: &Image) -> Option<[usize; 4]> {
    let mut b: Option<[usize; 4]> = None;
    for y in 0..img.h {
        for x in 0..img.w {
            if img.get(x, y)[3] > 0.5 {
                b = Some(match b {
                    Some(a) => [a[0].min(x), a[1].min(y), a[2].max(x), a[3].max(y)],
                    None => [x, y, x, y],
                });
            }
        }
    }
    b
}

#[test]
fn character_stroke_kind_colour_and_width_match_their_individual_references() {
    use filmcraft_project::graphic_design::{LayerExtra, StyleRun};
    for slot in ["stroke", "stroke2"] {
        let mut e = new_text_layer("HH", Vec2::new(30.0, 110.0), 70.0);
        set(&mut e, "tracking", ParamValue::Float(2000.0));
        set(&mut e, slot, ParamValue::Bool(true));
        set(&mut e, &format!("{slot}_color"), ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
        set(&mut e, &format!("{slot}_width"), ParamValue::Float(2.0));
        let render = |e| {
            let mut image = Image::new(400, 200);
            render_graphic_layers(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut image);
            image
        };
        let outer = render(e.clone());
        let mut inner_layer = e.clone();
        set(&mut inner_layer, &format!("{slot}_type"), ParamValue::Choice(2));
        set(&mut inner_layer, &format!("{slot}_width"), ParamValue::Float(10.0));
        set(&mut inner_layer, &format!("{slot}_color"), ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
        let inner = render(inner_layer);
        let (colour, width, kind) =
            if slot == "stroke" { ("strokeColor", "strokeWidth", "strokeType") } else { ("stroke2Color", "stroke2Width", "stroke2Type") };
        let style = serde_json::from_value(serde_json::json!({colour: [0.0, 0.0, 1.0, 1.0], width: 10.0, kind: 2})).unwrap();
        e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 0, end: 1, style }], ..Default::default() }));
        let mixed = render(e);
        for y in 0..mixed.h {
            for x in 0..mixed.w {
                let reference = if x < 150 { inner.get(x, y) } else { outer.get(x, y) };
                let actual = mixed.get(x, y);
                assert!(actual.iter().zip(reference).all(|(a, b)| (a - b).abs() < 1e-5), "{slot} at {x},{y}: {actual:?} vs {reference:?}");
            }
        }
    }
}

#[test]
fn per_character_stroke_width_and_enablement_render_independently() {
    use filmcraft_project::graphic_design::{LayerExtra, StyleRun};
    for slot in ["stroke", "stroke2"] {
        for kind in [0, 1, 2] {
            let mut e = new_text_layer("HH", Vec2::new(60.0, 100.0), 60.0);
            set(&mut e, "fill", ParamValue::Bool(false));
            set(&mut e, "tracking", ParamValue::Float(2000.0));
            set(&mut e, slot, ParamValue::Bool(true));
            set(&mut e, &format!("{slot}_width"), ParamValue::Float(2.0));
            set(&mut e, &format!("{slot}_type"), ParamValue::Choice(kind));
            let key = if slot == "stroke" { "strokeWidth" } else { "stroke2Width" };
            let style = serde_json::from_value(serde_json::json!({key: 40.0})).unwrap();
            e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 0, end: 1, style }], ..Default::default() }));
            let mut img = Image::new(400, 200);
            render_graphic_layers(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
            let (mut left, mut right, mut min_x) = (0, 0, 400);
            for y in 0..img.h {
                for x in 0..img.w {
                    if img.get(x, y)[3] > 0.5 {
                        min_x = min_x.min(x);
                        if x < 170 { left += 1 } else { right += 1 }
                    }
                }
            }
            // An inner stroke saturates once it fills the glyph's narrow stems.
            let thicker = if kind == 2 { left > right * 6 / 5 } else { left > right * 3 / 2 };
            assert!(right > 50 && thicker, "{slot}, kind {kind}: selected {left}, inherited {right}");
            if kind == 0 {
                assert!(min_x <= 28, "a wide character stroke must not be clipped to the layer's narrow width: {min_x}");
            }
        }
        for enabled in [false, true] {
            let mut e = new_text_layer("HH", Vec2::new(30.0, 100.0), 60.0);
            set(&mut e, "fill", ParamValue::Bool(false));
            set(&mut e, "tracking", ParamValue::Float(2000.0));
            set(&mut e, slot, ParamValue::Bool(enabled));
            let style = serde_json::from_value(serde_json::json!({slot: !enabled})).unwrap();
            e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 0, end: 1, style }], ..Default::default() }));
            let mut img = Image::new(400, 200);
            render_graphic_layers(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
            let visible = |start, end| (start..end).any(|x| (0..img.h).any(|y| img.get(x, y)[3] > 0.5));
            assert_eq!(visible(0, 140), !enabled, "{slot}: selected character's switch");
            assert_eq!(visible(140, 400), enabled, "{slot}: unselected character's switch");
        }
    }
}

#[test]
fn per_character_stroke_colours_render_independently() {
    use filmcraft_project::graphic_design::{LayerExtra, StyleRun};
    for slot in ["stroke", "stroke2"] {
        for kind in [0, 1, 2] {
            for filled in [false, true] {
                let mut e = new_text_layer("AAAA", Vec2::new(30.0, 110.0), 70.0);
                set(&mut e, "fill", ParamValue::Bool(filled));
                set(&mut e, slot, ParamValue::Bool(true));
                set(&mut e, &format!("{slot}_color"), ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
                set(&mut e, &format!("{slot}_width"), ParamValue::Float(5.0));
                set(&mut e, &format!("{slot}_type"), ParamValue::Choice(kind));
                let key = if slot == "stroke" { "strokeColor" } else { "stroke2Color" };
                let style = serde_json::from_value(serde_json::json!({key: [1.0, 0.0, 0.0, 1.0]})).unwrap();
                e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 2, end: 4, style }], ..Default::default() }));
                let mut img = Image::new(300, 160);
                render_graphic_layers(&[e.clone()], Tick::ZERO, (300, 160), &Affine::IDENTITY, &mut img);
                let spec = eval_layer(&e, Tick::ZERO, (300, 160)).unwrap();
                let LayerContent::Text(t) = &spec.content else { panic!() };
                let split = 30.0 + text_layout(t).caret(2).0;
                let (mut red, mut blue) = (0, 0);
                for y in 0..img.h {
                    for x in 0..img.w {
                        let p = img.get(x, y);
                        if p[3] > 0.9 && p[1] < 0.05 {
                            if p[0] > 0.9 && p[2] < 0.05 {
                                red += 1;
                                assert!(x as f32 > split - 6.0, "red stays on the selected half");
                            } else if p[2] > 0.9 && p[0] < 0.05 {
                                blue += 1;
                                assert!((x as f32) < split + 6.0, "blue stays on the unselected half");
                            }
                        }
                    }
                }
                assert!(red > 50 && blue > 50, "{slot} kind={kind} filled={filled}: red={red}, blue={blue}");
            }
        }
    }
}

#[test]
fn per_character_fill_and_size() {
    use filmcraft_project::graphic_design::{CharStyle, LayerExtra, StyleRun};
    let mut e = new_text_layer("AAAA", Vec2::new(20.0, 100.0), 60.0);
    set(&mut e, "fill_color", ParamValue::Color([1.0, 1.0, 1.0, 1.0]));
    let red = CharStyle { fill: Some([1.0, 0.0, 0.0, 1.0]), ..Default::default() };
    e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 2, end: 4, style: red }], ..Default::default() }));
    let mut img = Image::new(400, 200);
    render_graphic_layers(&[e.clone()], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
    let l = text_layout(match &eval_layer(&e, Tick::ZERO, (400, 200)).unwrap().content {
        LayerContent::Text(t) => t,
        _ => unreachable!(),
    });
    let split = 20.0 + l.caret(2).0;
    let (mut white, mut red_px) = (0, 0);
    for y in 0..200 {
        for x in 0..400 {
            let p = img.get(x, y);
            if p[3] > 0.9 {
                if p[1] > 0.9 {
                    white += 1;
                    assert!((x as f32) < split + 1.0, "white only in the first half at {x}");
                } else if p[0] > 0.9 && p[1] < 0.05 {
                    red_px += 1;
                    assert!((x as f32) > split - 1.0, "red only in the second half at {x}");
                }
            }
        }
    }
    assert!(white > 200 && red_px > 200, "{white} {red_px}");
    // a bigger run is taller and sits on the same baseline
    let big = CharStyle { size: Some(120.0), ..Default::default() };
    e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 3, end: 4, style: big }], ..Default::default() }));
    let mut img2 = Image::new(400, 200);
    render_graphic_layers(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img2);
    let (b1, b2) = (ink_box(&img).unwrap(), ink_box(&img2).unwrap());
    assert!(b2[1] + 30 < b1[1], "the big letter rises higher: {b1:?} {b2:?}");
    assert!(b2[3].abs_diff(b1[3]) <= 1, "same baseline: {b1:?} {b2:?}");
}

#[test]
fn pinned_box_follows_text_growth() {
    use filmcraft_project::graphic_design::{LayerExtra, Pin, PinTarget};
    let mut t = new_text_layer("Hi", Vec2::new(50.0, 100.0), 40.0);
    t.layer = Some(Box::new(LayerExtra { uid: 1, ..Default::default() }));
    let mut bx = new_shape_layer(0, Vec2::new(60.0, 90.0), Vec2::new(40.0, 40.0), vec![]);
    let tb = layer_bounds(&eval_layer(&t, Tick::ZERO, (400, 300)).unwrap());
    let padded = [tb[0] - 10.0, tb[1] - 10.0, tb[2] + 10.0, tb[3] + 10.0];
    let pin = Pin::new(PinTarget::Layer(1), [true; 4], padded, tb);
    bx.layer = Some(Box::new(LayerExtra { uid: 2, pin: Some(pin), ..Default::default() }));
    for text in ["Hi", "Hello there, world"] {
        set(&mut t, "text", ParamValue::Text(text.into()));
        let specs = graphic_specs(&[bx.clone(), t.clone()], Tick::ZERO, (400, 300));
        let (b, tt) = (layer_bounds(&specs[0]), layer_bounds(&specs[1]));
        for k in 0..4 {
            let want = tt[k] + if k < 2 { -10.0 } else { 10.0 };
            assert!((b[k] - want).abs() < 1e-3, "{text}: edge {k}: {b:?} vs {tt:?}");
        }
    }
}

#[test]
fn roll_moves_the_whole_graphic() {
    use filmcraft_project::graphic_design::{GraphicMeta, Roll, RollMode};
    let e = new_shape_layer(0, Vec2::new(200.0, 150.0), Vec2::new(100.0, 100.0), vec![]);
    let mut item = graphic_item(vec![e]);
    item.graphic = Some(Box::new(GraphicMeta {
        roll: Roll { mode: RollMode::Roll, start_off_screen: true, end_off_screen: true, ..Default::default() },
        ..Default::default()
    }));
    let at = |item: &TrackItem, s: f64| {
        let sp = item_layer_specs(item, Tick::from_seconds_f64(s), (400, 300));
        layer_bounds(&sp[0].1)
    };
    // the box (y 100..200) starts with its top at the frame bottom and ends above the frame
    assert!((at(&item, 0.0)[1] - 300.0).abs() < 1e-6);
    assert!(at(&item, 5.0)[3].abs() < 1e-6);
    // half way: offset (200 + (-200)) / 2 = 0 → back where it was laid out
    assert!((at(&item, 2.5)[1] - 100.0).abs() < 1e-6, "{:?}", at(&item, 2.5));
    let mut img = Image::new(400, 300);
    render_graphic(&item, Tick::from_seconds_f64(2.5), (400, 300), &Affine::IDENTITY, &mut img);
    assert!(img.get(200, 150)[3] > 0.9, "centre at mid-roll");
    let mut img0 = Image::new(400, 300);
    render_graphic(&item, Tick::ZERO, (400, 300), &Affine::IDENTITY, &mut img0);
    assert!(ink_box(&img0).is_none(), "off screen at the start");
}

#[test]
fn text_layer_renders_white_text_at_position() {
    let e = new_text_layer("HELLO", Vec2::new(100.0, 150.0), 60.0);
    let mut img = Image::new(400, 200);
    render_graphic_layers(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
    let ink: Vec<(usize, usize)> = (0..200).flat_map(|y| (0..400).map(move |x| (x, y))).filter(|&(x, y)| img.get(x, y)[3] > 0.5).collect();
    assert!(ink.len() > 500);
    let minx = ink.iter().map(|p| p.0).min().unwrap();
    let maxy = ink.iter().map(|p| p.1).max().unwrap();
    assert!((98..=106).contains(&minx), "starts at the position: {minx}");
    assert!((145..=152).contains(&maxy), "sits on the baseline: {maxy}");
    assert!(img.get(ink[0].0, ink[0].1)[0] > 0.4, "white");
}

#[test]
fn shape_appearance_layers() {
    let mut e = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(80.0, 40.0), vec![]);
    set(&mut e, "fill_color", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
    set(&mut e, "stroke", ParamValue::Bool(true));
    set(&mut e, "stroke_width", ParamValue::Float(6.0));
    set(&mut e, "stroke_color", ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
    set(&mut e, "shadow", ParamValue::Bool(true));
    set(&mut e, "shadow_distance", ParamValue::Float(20.0));
    set(&mut e, "shadow_blur", ParamValue::Float(0.0));
    let mut img = Image::new(200, 200);
    render_graphic_layers(&[e], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
    let p = img.get(100, 100);
    assert!(p[2] > 0.9 && p[0] < 0.05, "blue fill {p:?}");
    let s = img.get(100, 78);
    assert!(s[0] > 0.9 && s[2] < 0.05, "red outer stroke above the box {s:?}");
    // shadow: below-right of the box, outside the stroke
    let sh = img.get(150, 135);
    assert!(sh[3] > 0.5 && sh[0] < 0.05 && sh[2] < 0.05, "black shadow {sh:?}");
    assert_eq!(img.get(20, 20)[3], 0.0);
}

#[test]
fn linear_gradient_runs_left_to_right_on_a_shape_and_on_text() {
    let mut shape = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(80.0, 40.0), vec![]);
    set(&mut shape, "fill_kind", ParamValue::Choice(1));
    set(&mut shape, "gradient_start", ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
    set(&mut shape, "gradient_end", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
    set(&mut shape, "gradient_angle", ParamValue::Float(0.0));
    let mut img = Image::new(200, 200);
    render_graphic_layers(&[shape], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
    let left = img.get(70, 100);
    let right = img.get(130, 100);
    assert!(left[3] > 0.9 && left[0] > left[2], "redder on the left {left:?}");
    assert!(right[3] > 0.9 && right[2] > right[0], "bluer on the right {right:?}");

    let mut text = new_text_layer("HHHHHHHH", Vec2::new(16.0, 90.0), 64.0);
    set(&mut text, "fill_kind", ParamValue::Choice(1));
    set(&mut text, "gradient_start", ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
    set(&mut text, "gradient_end", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
    let mut img = Image::new(500, 180);
    render_graphic_layers(&[text], Tick::ZERO, (500, 180), &Affine::IDENTITY, &mut img);
    let ink: Vec<(usize, usize)> = (0..img.h).flat_map(|y| (0..img.w).map(move |x| (x, y))).filter(|&(x, y)| img.get(x, y)[3] > 0.8).collect();
    let minx = ink.iter().map(|p| p.0).min().unwrap();
    let maxx = ink.iter().map(|p| p.0).max().unwrap();
    let span = (maxx - minx).max(1);
    let (mut ln, mut rn, mut ls, mut rs) = (0.0_f32, 0.0, 0.0, 0.0);
    for &(x, y) in &ink {
        let p = img.get(x, y)[0];
        if x < minx + span / 3 {
            ls += p;
            ln += 1.0;
        } else if x > maxx - span / 3 {
            rs += p;
            rn += 1.0;
        }
    }
    assert!(ln > 30.0 && rn > 30.0, "ink on both ends of the title: {ln} {rn} x {minx}..{maxx}");
    assert!(ls / ln > rs / rn + 0.15, "text ramps from red to blue: {} {}", ls / ln, rs / rn);
}

#[test]
fn linear_gradient_blends_in_linear_light_and_turns_with_the_layer() {
    let mut shape = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(80.0, 40.0), vec![]);
    set(&mut shape, "fill_kind", ParamValue::Choice(1));
    set(&mut shape, "gradient_start", ParamValue::Color([0.0, 0.0, 0.0, 1.0]));
    set(&mut shape, "gradient_end", ParamValue::Color([1.0, 1.0, 1.0, 1.0]));
    let mut img = Image::new(200, 200);
    render_graphic_layers(&[shape.clone()], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
    let mid = img.get(100, 100)[0];
    // Linear-light midpoint is ~0.5. An sRGB midpoint converted to linear is ~0.21.
    assert!(mid > 0.4 && mid < 0.6, "centre of black→white is linear 0.5, got {mid}");
    assert!(img.get(70, 100)[0] < mid && mid < img.get(130, 100)[0]);

    set(&mut shape, "gradient_start", ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
    set(&mut shape, "gradient_end", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
    set(&mut shape, "rotation", ParamValue::Float(90.0));
    let mut turned = Image::new(200, 200);
    render_graphic_layers(&[shape], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut turned);
    let top = turned.get(100, 70);
    let bot = turned.get(100, 130);
    assert!(top[3] > 0.9 && bot[3] > 0.9, "the rotated ramp is inside the shape: {top:?} {bot:?}");
    assert!(top[0] > top[2], "clockwise 90° carries the start colour to the top {top:?}");
    assert!(bot[2] > bot[0], "and the end colour to the bottom {bot:?}");
}

#[test]
fn linear_gradient_keeps_a_per_character_fill_solid() {
    use filmcraft_project::graphic_design::{CharStyle, LayerExtra, StyleRun};
    let mut e = new_text_layer("AAAA", Vec2::new(20.0, 100.0), 60.0);
    set(&mut e, "fill_kind", ParamValue::Choice(1));
    set(&mut e, "gradient_start", ParamValue::Color([0.0, 1.0, 0.0, 1.0]));
    set(&mut e, "gradient_end", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
    let red = CharStyle { fill: Some([1.0, 0.0, 0.0, 1.0]), ..Default::default() };
    e.layer = Some(Box::new(LayerExtra { runs: vec![StyleRun { start: 2, end: 4, style: red }], ..Default::default() }));
    let mut img = Image::new(400, 200);
    render_graphic_layers(&[e.clone()], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
    let l = text_layout(match &eval_layer(&e, Tick::ZERO, (400, 200)).unwrap().content {
        LayerContent::Text(t) => t,
        _ => unreachable!(),
    });
    let split = 20.0 + l.caret(2).0;
    let (mut green, mut red_px) = (0, 0);
    for y in 0..200 {
        for x in 0..400 {
            let p = img.get(x, y);
            if p[3] < 0.8 {
                continue;
            }
            if (x as f32) < split - 1.0 && p[1] > p[0] && p[1] > p[2] {
                green += 1;
            } else if (x as f32) > split + 1.0 && p[0] > 0.9 && p[1] < 0.05 {
                red_px += 1;
            }
        }
    }
    assert!(green > 80 && red_px > 80, "gradient on the plain letters, solid red on the styled ones: {green} {red_px}");
}

#[test]
fn inner_and_centre_strokes() {
    for (kind, inside, outside) in [(2u32, true, false), (1, true, true)] {
        let mut e = new_shape_layer(2, Vec2::new(100.0, 100.0), Vec2::new(120.0, 120.0), vec![]);
        set(&mut e, "sides", ParamValue::Float(4.0));
        set(&mut e, "stroke", ParamValue::Bool(true));
        set(&mut e, "stroke_width", ParamValue::Float(6.0));
        set(&mut e, "stroke_type", ParamValue::Choice(kind));
        set(&mut e, "stroke_color", ParamValue::Color([0.0, 1.0, 0.0, 1.0]));
        let mut img = Image::new(200, 200);
        render_graphic_layers(&[e], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
        // diamond: top vertex at y = 40; probe straight below/above the right vertex (160, 100)
        let green = |x: usize| {
            let p = img.get(x, 100);
            p[1] > 0.9 && p[0] < 0.1
        };
        assert_eq!(green(157), inside, "kind {kind} inside");
        assert_eq!(green(161), outside, "kind {kind} outside");
        assert!(!green(120), "fill in the middle");
    }
}

#[test]
fn outer_stroke_without_fill_leaves_the_inside_empty() {
    let mut e = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(100.0, 100.0), vec![]);
    set(&mut e, "fill", ParamValue::Bool(false));
    set(&mut e, "stroke", ParamValue::Bool(true));
    set(&mut e, "stroke_width", ParamValue::Float(6.0));
    set(&mut e, "stroke_type", ParamValue::Choice(0));
    set(&mut e, "stroke_color", ParamValue::Color([0.0, 1.0, 0.0, 1.0]));
    let mut img = Image::new(200, 200);
    render_graphic_layers(&[e], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
    // rectangle spans 50..150: the ring is 150..156, everything left of the edge stays clear
    let p = img.get(153, 100);
    assert!(p[1] > 0.9 && p[0] < 0.1 && p[3] > 0.9, "ring is stroke-coloured: {p:?}");
    for x in [100, 140, 148] {
        assert_eq!(img.get(x, 100)[3], 0.0, "inside at x = {x}");
    }
}

#[test]
fn rotation_scale_and_opacity() {
    let mut e = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(100.0, 10.0), vec![]);
    set(&mut e, "rotation", ParamValue::Float(90.0));
    set(&mut e, "opacity", ParamValue::Float(50.0));
    let mut img = Image::new(200, 200);
    render_graphic_layers(&[e.clone()], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
    assert!((img.get(100, 60)[3] - 0.5).abs() < 0.02, "vertical after 90°");
    assert_eq!(img.get(60, 100)[3], 0.0);
    // a 2× output transform (e.g. Motion scale) draws vectors crisply at the larger size
    let mut big = Image::new(400, 400);
    render_graphic_layers(&[e], Tick::ZERO, (200, 200), &Affine::scale(2.0, 2.0), &mut big);
    assert!((big.get(200, 110)[3] - 0.5).abs() < 0.02);
    let q = layer_quad(&eval_layer(&find_effect("graphic_shape").unwrap().instance(), Tick::ZERO, (200, 200)).unwrap());
    assert!((q[0].x - (100.0 - 200.0)).abs() < 1e-6 && (q[2].y - (100.0 + 100.0)).abs() < 1e-6);
}

#[test]
fn tight_image_matches_full_render() {
    let a = new_text_layer("Tight", Vec2::new(50.0, 80.0), 40.0);
    let b = new_shape_layer(1, Vec2::new(150.0, 120.0), Vec2::new(60.0, 60.0), vec![]);
    let fx = vec![b, a];
    let mut full = Image::new(220, 160);
    let item = graphic_item(fx);
    render_graphic(&item, Tick::ZERO, (220, 160), &Affine::IDENTITY, &mut full);
    let (tight, x, y) = render_graphic_tight(&item, Tick::ZERO, (220, 160), &Affine::IDENTITY, 220, 160).unwrap();
    assert!(tight.w < 220 && tight.h < 160);
    for yy in 0..tight.h {
        for xx in 0..tight.w {
            let (p, q) = (tight.get(xx, yy), full.get(xx + x as usize, yy + y as usize));
            assert!((p[3] - q[3]).abs() < 1e-5);
        }
    }
}

/// #3361: Responsive Design – Time remaps the keyframes of the graphic's *layers* only. The clip's
/// own effects and masks (Opacity, Motion, ...) are read at plain media time, like on any clip,
/// so trimming a graphic with an outro moves a layer's outro animation with the clip end but not a
/// keyframe on the clip's own effect. Documented in docs/graphics.md.
#[test]
fn responsive_time_remaps_layer_keyframes_not_the_clips_own_effects() {
    use filmcraft_project::graphic_design::GraphicMeta;
    let sec = Tick::from_seconds_f64;
    let mut layer = new_shape_layer(0, Vec2::new(200.0, 150.0), Vec2::new(100.0, 100.0), vec![]);
    // layer opacity fades 100 → 0 over the designed outro (4 s .. 5 s)
    let p = layer.params.get_mut("opacity").expect("opacity");
    p.put_keyframe(sec(4.0), ParamValue::Float(100.0));
    p.put_keyframe(sec(5.0), ParamValue::Float(0.0));
    let mut item = graphic_item(vec![layer]);
    // the same fade on the clip's own (intrinsic) Opacity effect, at media times
    let own = item.effect_mut("opacity").expect("intrinsic opacity");
    let p = own.params.get_mut("opacity").expect("opacity");
    p.put_keyframe(sec(4.0), ParamValue::Float(100.0));
    p.put_keyframe(sec(5.0), ParamValue::Float(0.0));
    // designed 5 s with a 1 s outro, then trimmed to 3 s
    item.graphic = Some(Box::new(GraphicMeta { outro: sec(1.0), design_duration: sec(5.0), ..Default::default() }));
    item.duration = sec(3.0);
    // half way through the trimmed clip's outro (clip time 2.5 s of 3 s)
    let mt = sec(2.5);
    let (t, _, _) = graphic_time(&item, mt);
    assert_eq!(t, sec(4.5), "the layer reads its keyframes half way through the designed outro");
    let layer_opacity = item_layer_specs(&item, mt, (400, 300))[0].1.transform.opacity;
    assert!((layer_opacity - 0.5).abs() < 1e-4, "layer fade is half done: {layer_opacity}");
    // the clip's own Opacity is read at media time: 2.5 s is before its keyframes, so still 100 %
    assert_eq!(crate::opacity_blend(&item, item.effect_time_at(mt)).0, 1.0);
    // a head trim advances source_in; the clip's keyframes stay at their media times (4.5 s: half)
    item.source_in = sec(2.0);
    let own_at = |item: &TrackItem, clip_t: f64| crate::opacity_blend(item, item.effect_time_at(sec(clip_t))).0;
    assert!((own_at(&item, 2.5) - 0.5).abs() < 1e-4, "media 4.5 s: {}", own_at(&item, 2.5));
    assert!((own_at(&item, 0.0) - 1.0).abs() < 1e-4, "media 2 s: {}", own_at(&item, 0.0));
}

#[test]
fn style_runs_that_own_no_glyph_cost_no_colour_group() {
    use filmcraft_project::graphic_design::{CharStyle, LayerExtra, StyleRun};
    let mut e = new_text_layer("A", Vec2::new(20.0, 100.0), 60.0);
    set(&mut e, "fill_color", ParamValue::Color([1.0, 1.0, 1.0, 1.0]));
    // 3000 runs over the one character, each with its own fill: only the last one wins it, and
    // the rest own nothing, so they must not each cost a full-size mask and pass
    let runs: Vec<StyleRun> =
        (0..3000).map(|i| StyleRun { start: 0, end: 1, style: CharStyle { fill: Some([1.0, i as f32 / 3000.0, 0.0, 1.0]), ..Default::default() } }).collect();
    e.layer = Some(Box::new(LayerExtra { runs, ..Default::default() }));
    let mut img = Image::new(2000, 1000);
    let t = std::time::Instant::now();
    render_graphic_layers(&[e], Tick::ZERO, (2000, 1000), &Affine::IDENTITY, &mut img);
    assert!(t.elapsed() < std::time::Duration::from_secs(15), "{:?}", t.elapsed());
    assert!(ink_box(&img).is_some(), "the letter is still drawn");
}