GitCorner

Code

ossartcrafttexturecraft🌐
d84914ef1e5a
//! Layer-panel thumbnails: they equal a plain CPU evaluation of the same sub-stack at 64 px,
//! follow edits, drop stale and vanished work, and only render what was asked for.

use std::time::{Duration, Instant};

use serde_json::{Value, json};
use texturecraft_engine::compose::{Inputs, ThumbImage, ThumbTarget, all_tiles, flatten_layer, mask_image};
use texturecraft_engine::core::{Channel, ChannelKind, LayerId};
use texturecraft_engine::geom::UvGBuffer;
use texturecraft_engine::geom::primitives;
use texturecraft_engine::texel::{from_u16, from_u16_signed, linear_to_srgb};
use texturecraft_engine::thumbs::{CACHE_ENTRIES, ThumbService};
use texturecraft_engine::{Session, execute};

const N: u32 = 64;

fn session() -> Session {
    Session::new_project("t", primitives::sphere(1.0, 32, 16), "builtin:sphere", None, 256).unwrap()
}

fn id(v: Value, key: &str) -> LayerId {
    LayerId(v[key].as_u64().unwrap())
}

/// A fill layer with two content effects (invert, then posterize) and a masked generator.
struct Stack {
    layer: LayerId,
    invert: LayerId,
    posterize: LayerId,
    gen_: LayerId,
}

fn stack(s: &mut Session) -> Stack {
    let layer = id(execute(s, "layer.add.fill", &json!({"color": "#336699", "roughness": 0.2})).unwrap(), "layer");
    let invert = id(execute(s, "effect.add.filter", &json!({"target": "content", "filter": "invert"})).unwrap(), "effect");
    let posterize = id(execute(s, "effect.add.filter", &json!({"target": "content", "filter": "posterize"})).unwrap(), "effect");
    execute(s, "mask.add.black", &Value::Null).unwrap();
    let gen_ = id(execute(s, "effect.add.generator", &json!({"generator": "position", "level": 0.5})).unwrap(), "effect");
    Stack { layer, invert, posterize, gen_ }
}

fn inputs<'a>(s: &'a Session, project: &'a texturecraft_engine::core::Project, gbuf: &'a UvGBuffer) -> Inputs<'a> {
    static EMPTY_BAKED: std::sync::LazyLock<texturecraft_engine::compose::BakedMaps> = std::sync::LazyLock::new(Default::default);
    let baked = s.doc.baked.get(&0).unwrap_or(&EMPTY_BAKED);
    Inputs {
        project,
        ts: 0,
        mesh: &s.mesh,
        gbuf,
        pixels: &s.doc.pixels,
        baked,
        block_scales: Default::default(),
        preview: None,
        images: &s.images,
        bounds: s.mesh.bounds(),
    }
}

/// The reference: the same sub-stack cut by hand and evaluated at 64 px with the ordinary CPU
/// evaluator (the mask with `mask_image`, the content with `flatten_layer`), then encoded.
fn oracle(s: &Session, target: ThumbTarget) -> ThumbImage {
    let gbuf = UvGBuffer::new(&s.mesh, 0, N, N);
    let mut p = s.doc.project.clone();
    let (layer, upto, channel) = match target {
        ThumbTarget::Content { layer, channel } => (layer, None, channel),
        ThumbTarget::Mask { layer } => (layer, None, Channel::BaseColor),
        ThumbTarget::Stage { effect, channel } => (p.effect(effect).unwrap().0, Some(effect), channel),
    };
    let l = p.layers.get_mut(&layer).unwrap();
    l.visible = true;
    let in_mask = upto.is_some_and(|e| l.mask.as_ref().is_some_and(|m| m.effects.iter().any(|x| x.id == e))) || matches!(target, ThumbTarget::Mask { .. });
    if in_mask {
        let m = l.mask.as_mut().unwrap();
        m.enabled = true;
        if let Some(e) = upto {
            let k = m.effects.iter().position(|x| x.id == e).unwrap();
            m.effects.truncate(k + 1);
        }
        let gray = mask_image(&inputs(s, &p, &gbuf), layer, N).unwrap();
        let rgba = gray.iter().enumerate().flat_map(|(i, g)| [*g, *g, *g, if gbuf.covered(i) { 255 } else { 0 }]).collect();
        return ThumbImage { width: N, height: N, rgba };
    }
    l.mask = None;
    l.channels.insert(channel, texturecraft_engine::core::ChannelBlend::default());
    if let Some(e) = upto {
        let k = l.content_effects.iter().position(|x| x.id == e).unwrap();
        l.content_effects.truncate(k + 1);
    }
    // A paint or fill layer: its own (premultiplied value, coverage), coverage as alpha.
    let flat = flatten_layer(&inputs(s, &p, &gbuf), layer, &all_tiles(N, N)).unwrap();
    let byte = |v: f32| (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
    let mut rgba = vec![0u8; (N * N * 4) as usize];
    let comps = channel.components();
    for (_, _, buf) in flat.iter().filter(|(c, _, _)| *c == channel) {
        for (i, px) in buf.chunks_exact(comps + 1).enumerate() {
            let a = from_u16(px[comps]);
            if a <= 0.0 {
                continue;
            }
            let v: [f32; 3] = std::array::from_fn(|k| {
                let raw = px[k.min(comps - 1)];
                (if channel.kind() == ChannelKind::Signed { from_u16_signed(raw) } else { from_u16(raw) }) / a
            });
            let px = match channel.kind() {
                ChannelKind::Color => v.map(|c| byte(linear_to_srgb(c.clamp(0.0, 1.0)))),
                ChannelKind::Signed => v.map(|c| byte(c * 0.5 + 0.5)),
                _ => v.map(byte),
            };
            rgba[i * 4..i * 4 + 4].copy_from_slice(&[px[0], px[1], px[2], byte(a)]);
        }
    }
    ThumbImage { width: N, height: N, rgba }
}

/// Frames of `svc` until every target is current (or a timeout).
fn settle(svc: &mut ThumbService, s: &Session, targets: &[ThumbTarget], clock: &mut f64) {
    let t0 = Instant::now();
    loop {
        *clock += 0.2;
        svc.begin_frame(s, *clock);
        for t in targets {
            svc.get(s, *t);
        }
        svc.poll(s);
        if targets.iter().all(|t| svc.is_fresh(*t)) {
            return;
        }
        assert!(t0.elapsed() < Duration::from_secs(60), "thumbnails never settled");
        std::thread::sleep(Duration::from_millis(2));
    }
}

fn image(svc: &mut ThumbService, s: &Session, t: ThumbTarget) -> ThumbImage {
    (*svc.get(s, t).image.expect("a picture")).clone()
}

#[test]
fn thumbnails_equal_a_cpu_evaluation_of_the_same_sub_stack() {
    let mut session = session();
    let stack = stack(&mut session);
    let base_color = Channel::BaseColor;
    let targets = [
        ThumbTarget::Content { layer: stack.layer, channel: base_color },
        ThumbTarget::Content { layer: stack.layer, channel: Channel::Roughness },
        ThumbTarget::Mask { layer: stack.layer },
        ThumbTarget::Stage { effect: stack.invert, channel: base_color },
        ThumbTarget::Stage { effect: stack.posterize, channel: base_color },
        ThumbTarget::Stage { effect: stack.gen_, channel: base_color },
    ];
    let (mut service, mut clock) = (ThumbService::new(), 0.0);

    settle(&mut service, &session, &targets, &mut clock);

    for target in targets {
        assert_eq!(image(&mut service, &session, target), oracle(&session, target), "{target:?}");
    }

    // The first stage inverts #336699 in linear light
    let inverted = image(&mut service, &session, targets[3]);
    let pixel = inverted.rgba.as_chunks::<4>().0.iter().find(|pixel| pixel[3] == 255).unwrap();
    let expected = |byte: f32| (linear_to_srgb(1.0 - texturecraft_engine::texel::srgb_to_linear(byte / 255.0)) * 255.0 + 0.5) as i32;
    assert!((i32::from(pixel[0]) - expected(51.0)).abs() <= 1 && (i32::from(pixel[2]) - expected(153.0)).abs() <= 1, "{pixel:?}");

    // A position generator must produce a nonuniform mask
    let mask = image(&mut service, &session, targets[2]);
    let grays: Vec<u8> = mask.rgba.as_chunks::<4>().0.iter().filter(|pixel| pixel[3] == 255).map(|pixel| pixel[0]).collect();
    assert!(grays.iter().max() != grays.iter().min());
}

#[test]
fn earlier_stages_never_show_later_effects_and_hidden_effects_are_bypassed() {
    let mut s = session();
    let st = stack(&mut s);
    let base = Channel::BaseColor;
    let (first, second) = (ThumbTarget::Stage { effect: st.invert, channel: base }, ThumbTarget::Stage { effect: st.posterize, channel: base });
    let (mut svc, mut clock) = (ThumbService::new(), 0.0);
    settle(&mut svc, &s, &[first, second], &mut clock);
    let (a, b) = (image(&mut svc, &s, first), image(&mut svc, &s, second));
    // Hide the second effect: its stage now shows the first one's result; the first is unchanged.
    execute(&mut s, "effect.set", &json!({"effect": st.posterize.0, "visible": false})).unwrap();
    settle(&mut svc, &s, &[first, second], &mut clock);
    assert_eq!(image(&mut svc, &s, first), a);
    assert_eq!(image(&mut svc, &s, second), a);
    assert_ne!(a, b, "posterize should change something for the test to mean anything");
    // And the content thumbnail (everything) follows.
    let all = ThumbTarget::Content { layer: st.layer, channel: base };
    settle(&mut svc, &s, &[all], &mut clock);
    assert_eq!(image(&mut svc, &s, all), a);
}

#[test]
fn editing_invalidates_and_unrelated_changes_do_not() {
    let mut s = session();
    let st = stack(&mut s);
    let t = ThumbTarget::Content { layer: st.layer, channel: Channel::BaseColor };
    let (mut svc, mut clock) = (ThumbService::new(), 0.0);
    settle(&mut svc, &s, &[t], &mut clock);
    let before = image(&mut svc, &s, t);
    let rendered = svc.rendered;
    // A camera move changes the session revision but no thumbnail input: nothing is re-rendered.
    execute(&mut s, "camera.set", &json!({"yaw": 0.7})).ok();
    s.revision += 1;
    for _ in 0..3 {
        clock += 0.3;
        svc.begin_frame(&s, clock);
        svc.get(&s, t);
        svc.poll(&s);
    }
    assert!(svc.is_fresh(t));
    assert_eq!(svc.rendered, rendered, "an unrelated change re-rendered a thumbnail");
    // An edit of the layer re-renders it, and the new picture is the new oracle.
    execute(&mut s, "effect.set", &json!({"effect": st.invert.0, "visible": false})).unwrap();
    clock += 0.3;
    svc.begin_frame(&s, clock);
    assert!(!svc.is_fresh(t));
    settle(&mut svc, &s, &[t], &mut clock);
    let after = image(&mut svc, &s, t);
    assert_ne!(before, after);
    assert_eq!(after, oracle(&s, t));
    // Undo brings the first picture back.
    execute(&mut s, "edit.undo", &Value::Null).unwrap();
    settle(&mut svc, &s, &[t], &mut clock);
    assert_eq!(image(&mut svc, &s, t), before);
}

#[test]
fn deleting_a_layer_with_a_pending_thumbnail_is_harmless() {
    let mut s = session();
    let st = stack(&mut s);
    let (a, b) = (ThumbTarget::Content { layer: st.layer, channel: Channel::BaseColor }, ThumbTarget::Mask { layer: st.layer });
    let mut svc = ThumbService::new();
    // Queue the work and hand it to the worker, then delete the layer before collecting.
    svc.begin_frame(&s, 1.0);
    svc.get(&s, a);
    svc.get(&s, b);
    svc.poll(&s);
    execute(&mut s, "layer.remove", &json!({"layer": st.layer.0})).unwrap();
    let mut clock = 2.0;
    for _ in 0..200 {
        clock += 0.2;
        svc.begin_frame(&s, clock);
        // The row is gone, so nobody asks for it any more; the pending result is dropped.
        svc.poll(&s);
        std::thread::sleep(Duration::from_millis(2));
    }
    assert!(!svc.is_fresh(a) && !svc.is_fresh(b));
    assert_eq!(svc.cached(), 0);
    assert!(!svc.busy());
    // Asking for a layer that no longer exists renders nothing and does not panic either.
    settle_gone(&mut svc, &s, a, &mut clock);
}

fn settle_gone(svc: &mut ThumbService, s: &Session, t: ThumbTarget, clock: &mut f64) {
    for _ in 0..20 {
        *clock += 0.2;
        svc.begin_frame(s, *clock);
        svc.get(s, t);
        svc.poll(s);
        std::thread::sleep(Duration::from_millis(2));
    }
    assert!(svc.get(s, t).image.is_none());
}

#[test]
fn a_result_of_an_older_document_never_replaces_a_newer_one() {
    let mut s = session();
    let st = stack(&mut s);
    let t = ThumbTarget::Content { layer: st.layer, channel: Channel::BaseColor };
    let mut svc = ThumbService::new();
    svc.begin_frame(&s, 1.0);
    svc.get(&s, t);
    svc.poll(&s); // the job of the first document is running
    execute(&mut s, "effect.set", &json!({"effect": st.invert.0, "visible": false})).unwrap();
    let mut clock = 2.0;
    settle(&mut svc, &s, &[t], &mut clock);
    // Whatever the first job returned, what is shown is the current document.
    assert_eq!(image(&mut svc, &s, t), oracle(&s, t));
}

#[test]
fn only_requested_rows_render_and_the_cache_is_bounded() {
    let mut session = session();
    let layers: Vec<LayerId> = (0..(CACHE_ENTRIES + 30)).map(|_| id(execute(&mut session, "layer.add.paint", &Value::Null).unwrap(), "layer")).collect();
    let target = |layer: LayerId| ThumbTarget::Content { layer, channel: Channel::BaseColor };
    let mut service = ThumbService::new();

    // A frame asks for six rows, then scrolling leaves only one visible
    service.begin_frame(&session, 1.0);
    for layer in &layers[..6] {
        service.get(&session, target(*layer));
    }
    service.poll(&session);
    let mut clock = 2.0;
    for _ in 0..300 {
        clock += 0.2;
        service.begin_frame(&session, clock);
        service.get(&session, target(layers[0]));
        service.poll(&session);
        std::thread::sleep(Duration::from_millis(1));
    }

    assert!(service.is_fresh(target(layers[0])));
    let completed = layers[..6].iter().filter(|layer| service.is_fresh(target(**layer))).count();
    assert!(completed <= 3, "{completed} of the scrolled-away rows were rendered");

    // Scrolling through every layer evicts pictures and releases their allocations
    let mut images = Vec::new();
    for chunk in layers.chunks(12) {
        let targets: Vec<ThumbTarget> = chunk.iter().map(|layer| target(*layer)).collect();
        settle(&mut service, &session, &targets, &mut clock);
        for target in targets {
            images.push(std::sync::Arc::downgrade(&service.get(&session, target).image.unwrap()));
        }
        assert!(service.cached() <= CACHE_ENTRIES, "{}", service.cached());
    }
    clock += 0.2;
    service.begin_frame(&session, clock);
    service.poll(&session);

    assert!(service.cached() <= CACHE_ENTRIES, "{}", service.cached());
    assert!(images.len() > CACHE_ENTRIES);
    assert!(images.first().unwrap().upgrade().is_none(), "the oldest image was evicted");
    assert_eq!(images.iter().filter(|image| image.strong_count() > 0).count(), service.cached());

    drop(service);

    assert!(images.iter().all(|image| image.upgrade().is_none()), "closing the cache releases every picture");
}

#[test]
fn an_empty_paint_layer_is_transparent_and_a_folder_composites_its_children() {
    let mut session = session();
    let paint = id(execute(&mut session, "layer.add.paint", &Value::Null).unwrap(), "layer");
    let fill = id(execute(&mut session, "layer.add.fill", &json!({"color": "#336699"})).unwrap(), "layer");
    let folder = id(execute(&mut session, "layer.group", &json!({"layer": fill.0})).unwrap(), "layer");
    let paint_target = ThumbTarget::Content { layer: paint, channel: Channel::BaseColor };
    let folder_target = ThumbTarget::Content { layer: folder, channel: Channel::BaseColor };
    let (mut service, mut clock) = (ThumbService::new(), 0.0);

    settle(&mut service, &session, &[paint_target, folder_target], &mut clock);

    assert!(image(&mut service, &session, paint_target).rgba.as_chunks::<4>().0.iter().all(|pixel| pixel[3] == 0), "nothing painted: nothing shown");
    let folder_image = image(&mut service, &session, folder_target);
    let pixel = folder_image.rgba.as_chunks::<4>().0.iter().find(|pixel| pixel[3] == 255).unwrap();
    assert!((i32::from(pixel[0]) - 51).abs() <= 1 && (i32::from(pixel[2]) - 153).abs() <= 1, "{pixel:?}");
}

#[test]
fn instances_preview_the_source_content_and_inherited_mask() {
    use texturecraft_engine::thumbs::{GbufCache, ThumbSnapshot};

    let mut session = session();
    let stack = stack(&mut session);
    let instance = id(execute(&mut session, "layer.instance", &json!({"layer": stack.layer.0})).unwrap(), "layer");
    let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();

    for channel in [Channel::BaseColor, Channel::Roughness] {
        let source = snapshot.render(ThumbTarget::Content { layer: stack.layer, channel }).unwrap();
        let preview = snapshot.render(ThumbTarget::Content { layer: instance, channel });

        assert!(preview == Some(source), "the instance inherits {channel:?} from its source");
    }

    assert_eq!(snapshot.render(ThumbTarget::Mask { layer: instance }), snapshot.render(ThumbTarget::Mask { layer: stack.layer }));
}

/// A lower height anchor and an independent upper fill that can read it.
fn anchor_stack() -> (Session, LayerId, LayerId) {
    let mut session = session();
    execute(&mut session, "layer.add.fill", &json!({"height": 0.25})).unwrap();
    let anchor = id(execute(&mut session, "effect.add.anchor", &Value::Null).unwrap(), "effect");
    let layer = id(execute(&mut session, "layer.add.fill", &Value::Null).unwrap(), "layer");
    (session, anchor, layer)
}

#[test]
fn thumbnails_keep_anchor_inputs_from_lower_layers() {
    use texturecraft_engine::thumbs::{GbufCache, ThumbSnapshot};

    let (mut session, anchor, layer) = anchor_stack();
    execute(&mut session, "layer.fill.set", &json!({"channel": "roughness", "anchor": anchor.0, "anchorChannel": "height"})).unwrap();
    execute(&mut session, "mask.add.black", &Value::Null).unwrap();
    let mask_effect = id(execute(&mut session, "effect.add.fill", &json!({"anchor": anchor.0, "anchorChannel": "height"})).unwrap(), "effect");
    let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();

    for target in [
        ThumbTarget::Content { layer, channel: Channel::Roughness },
        ThumbTarget::Mask { layer },
        ThumbTarget::Stage { effect: mask_effect, channel: Channel::BaseColor },
    ] {
        let image = snapshot.render(target).unwrap();
        let pixel = image.rgba.as_chunks::<4>().0.iter().find(|pixel| pixel[3] == 255).unwrap();

        assert!((i32::from(pixel[0]) - 64).abs() <= 1, "{target:?} must read the lower anchor's 0.25, got {pixel:?}");
    }
}

#[test]
fn folder_thumbnails_keep_anchors_outside_the_folder() {
    use texturecraft_engine::thumbs::{GbufCache, ThumbSnapshot};

    let (mut session, anchor, layer) = anchor_stack();
    execute(&mut session, "layer.fill.set", &json!({"channel": "roughness", "anchor": anchor.0, "anchorChannel": "height"})).unwrap();
    let folder = id(execute(&mut session, "layer.group", &json!({"layer": layer.0})).unwrap(), "layer");
    let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();

    let image = snapshot.render(ThumbTarget::Content { layer: folder, channel: Channel::Roughness }).unwrap();
    let pixel = image.rgba.as_chunks::<4>().0.iter().find(|pixel| pixel[3] == 255).unwrap();

    assert!((i32::from(pixel[0]) - 64).abs() <= 1, "the folder must read the external anchor's 0.25, got {pixel:?}");
}

#[test]
fn effect_only_anchor_reads_keep_the_lower_stack() {
    use texturecraft_engine::thumbs::{GbufCache, ThumbSnapshot};

    for target_kind in ["content", "mask"] {
        let (mut session, anchor, layer) = anchor_stack();
        if target_kind == "mask" {
            execute(&mut session, "mask.add.black", &Value::Null).unwrap();
        }
        let effect = id(execute(&mut session, "effect.add.fill", &json!({"target": target_kind})).unwrap(), "effect");
        if target_kind == "content" {
            execute(&mut session, "layer.fill.set", &json!({"effect": effect.0, "channel": "roughness", "anchor": anchor.0, "anchorChannel": "height"}))
                .unwrap();
        } else {
            execute(&mut session, "effect.set", &json!({"effect": effect.0, "anchor": anchor.0, "anchorChannel": "height"})).unwrap();
        }
        let target = if target_kind == "content" { ThumbTarget::Content { layer, channel: Channel::Roughness } } else { ThumbTarget::Mask { layer } };
        let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();

        for target in [target, ThumbTarget::Stage { effect, channel: Channel::Roughness }] {
            let image = snapshot.render(target).unwrap();
            let pixel = image.rgba.as_chunks::<4>().0.iter().find(|pixel| pixel[3] == 255).unwrap();

            assert!((i32::from(pixel[0]) - 64).abs() <= 1, "{target_kind} {target:?} must read the lower anchor's 0.25, got {pixel:?}");
        }
    }
}