effectcraft/crates/render/src/tests/guides.rs

//! Guide layers: drawn in their own comp's viewer (`RenderOpts::guides`), never when that comp is
//! nested in another (precomp, collapsed precomp, 2D or 3D), and never in final renders.

use effectcraft_color::Label;
use effectcraft_keyframe::Value;
use effectcraft_project::build;
use effectcraft_project::{BitDepth, Comp, ItemId, ItemKind, Layer, LayerSource, Project, Solid};
use effectcraft_time::{FrameRate, Tick};

use crate::{NoFootage, RenderOpts, Renderer};

fn solid(p: &mut Project, comp: &Comp, color: [f32; 3], size: (u32, u32), three_d: bool) -> Layer {
    let sid = p.add_item("S", Label::Red, None, ItemKind::Solid(Solid { color, width: size.0, height: size.1, pixel_aspect: 1.0 }));
    let mut l = build::layer(p, comp, "S", LayerSource::Solid { item: sid }, size, None);
    l.props.prop_mut("transform/position").unwrap().value = Value::Vec3([50.0, 50.0, 0.0]);
    l.switches.three_d = three_d;
    l
}

#[derive(Clone, Copy, Debug)]
enum Nest {
    /// A plain precomp layer (the nested comp rendered on its own, then composited).
    Precomp,
    /// Collapse Transformations on a 2D precomp layer.
    Collapsed,
    /// A collapsed 3D precomp in a Classic 3D comp.
    Collapsed3d,
    /// A collapsed 3D precomp in an Advanced 3D comp.
    CollapsedAdvanced,
}

/// "Inner": a red 100×100 background with a green 40×40 guide layer in the middle; "Outer": the
/// same size, holding only Inner nested as `nest`.
fn scene(nest: Nest) -> (Project, ItemId, ItemId) {
    let three_d = matches!(nest, Nest::Collapsed3d | Nest::CollapsedAdvanced);
    let mut p = Project::default();
    p.settings.bit_depth = BitDepth::Bpc32;
    let inner = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
    let mut guide = solid(&mut p, &inner, [0.0, 1.0, 0.0], (40, 40), three_d);
    guide.switches.guide = true;
    let bg = solid(&mut p, &inner, [1.0, 0.0, 0.0], (100, 100), three_d);
    let mut inner = inner;
    inner.layers = vec![guide, bg].into();
    let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
    let mut outer = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
    if matches!(nest, Nest::CollapsedAdvanced) {
        outer.renderer = effectcraft_project::Renderer::Advanced3D;
    }
    let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (100, 100), None);
    pre.switches.collapse = !matches!(nest, Nest::Precomp);
    pre.switches.three_d = three_d;
    outer.layers = vec![pre].into();
    let oid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(outer.into()));
    (p, iid, oid)
}

/// The centre pixel of `comp` rendered with or without guide layers.
fn centre(p: &Project, comp: ItemId, guides: bool) -> [f32; 4] {
    Renderer::new(p, &NoFootage, RenderOpts { guides, ..Default::default() }).comp_frame(comp, Tick::ZERO).get(50, 50)
}

fn is_green(c: [f32; 4]) -> bool {
    c[1] > 0.9 && c[0] < 0.1
}

fn is_red(c: [f32; 4]) -> bool {
    c[0] > 0.9 && c[1] < 0.1
}

#[test]
fn guide_layer_renders_in_its_own_comp_with_guides_on() {
    let (p, inner, _) = scene(Nest::Precomp);
    let c = centre(&p, inner, true);
    assert!(is_green(c), "guide layer drawn in its own comp's viewer: {c:?}");
}

#[test]
fn final_renders_leave_guide_layers_out_by_default() {
    assert!(!RenderOpts::default().guides);
    let (p, inner, _) = scene(Nest::Precomp);
    let c = centre(&p, inner, false);
    assert!(is_red(c), "guide layer left out of final renders: {c:?}");
}

#[test]
fn guide_layers_of_a_nested_comp_never_render_in_the_parent() {
    for nest in [Nest::Precomp, Nest::Collapsed, Nest::Collapsed3d, Nest::CollapsedAdvanced] {
        let (p, inner, outer) = scene(nest);
        // The nested comp's own viewer still shows them…
        let own = centre(&p, inner, true);
        assert!(is_green(own), "{nest:?}: guide layer in its own comp: {own:?}");
        // …but not the parent's viewer (guides on) nor its final render.
        for guides in [true, false] {
            let c = centre(&p, outer, guides);
            assert!(is_red(c), "{nest:?}, guides {guides}: nested guide layer drawn in the parent: {c:?}");
        }
    }
}

#[test]
fn a_guide_precomp_layer_of_the_top_comp_follows_the_guides_option() {
    // The precomp layer itself is a guide layer in the top comp: shown in the viewer, not in
    // final renders.
    let (mut p, _, outer) = scene(Nest::Precomp);
    p.comp_mut(outer).unwrap().layers[0].switches.guide = true;
    assert!(is_red(centre(&p, outer, true)));
    assert!(centre(&p, outer, false)[3] < 0.01, "nothing drawn without guides");
}