nordisk/facett

facett-plandag/tests/flow_gpu.rs

//! Real Falsett callbacks and a metric/group-navigation golden.
//! Initial reference: Apple M2 Pro / Metal; see snapshots/README.md.
//! Compare: FACETT_TEST_GPU=integrated cargo test -p facett-plandag --features wgpu --test flow_gpu
//! UPDATE_SNAPSHOTS=1 is only for intended, reviewed reference changes.
//! Other hardware comparisons are separate evidence; missing references fail.
#![cfg(feature = "wgpu")]

use egui_kittest::{Harness, wgpu::WgpuTestRenderer};
use facett_core::{Facet, render::lane};
use facett_flow::gpu;
use facett_plandag::{CostMetric, Msg, PlanDagView};

fn enabled() -> bool {
    let enabled = matches!(
        std::env::var("FACETT_TEST_GPU").as_deref(),
        Ok("integrated" | "discrete" | "software")
    );
    if !enabled {
        eprintln!("SKIPPED: no GPU proof; set FACETT_TEST_GPU=integrated|discrete|software");
    }
    enabled
}

fn harness() -> (Harness<'static, PlanDagView>, egui_wgpu::RenderState) {
    let setup = facett_core::render::gpu::adapter_wgpu::facett_wgpu_options().wgpu_setup;
    let rs = egui_kittest::wgpu::create_render_state(setup, Default::default());
    assert!(gpu::install_renderer(&rs));
    let h = Harness::builder()
        .with_size(egui::vec2(1000.0, 680.0))
        .with_pixels_per_point(1.0)
        .renderer(WgpuTestRenderer::from_render_state(rs.clone()))
        .build_ui_state(
            |ui, v: &mut PlanDagView| {
                facett_core::set_theme(ui.ctx(), facett_core::Theme::sci_fi());
                v.ui(ui);
            },
            PlanDagView::local(),
        );
    (h, rs)
}

fn frame(h: &mut Harness<'_, PlanDagView>) -> image::RgbaImage {
    let before = lane::frames_of(gpu::lane_name());
    h.step();
    let image = h.render().expect("real GPU framebuffer");
    assert!(
        lane::frames_of(gpu::lane_name()) > before,
        "CPU paint cannot satisfy this proof"
    );
    image
}
fn bytes() -> u64 {
    lane::clock_stats_of(gpu::lane_name()).upload_bytes_total
}
fn diff(a: &image::RgbaImage, b: &image::RgbaImage) -> usize {
    assert_eq!(a.dimensions(), b.dimensions());
    a.pixels().zip(b.pixels()).filter(|(a, b)| a != b).count()
}

#[test]
fn metrics_and_camera_reuse_geometry_but_collapse_uploads_new_geometry() {
    if !enabled() {
        return;
    }
    let _turn = facett_core::render::gputurn::hold();
    let (mut h, rs) = harness();
    frame(&mut h);
    frame(&mut h);
    let initial = frame(&mut h);
    let generation = h.state().flow_scene().generation();
    let targets = gpu::residency(&rs);
    assert_eq!(targets.0, 1);
    let initial_bytes = bytes();
    assert_eq!(diff(&initial, &frame(&mut h)), 0);
    assert_eq!(bytes(), initial_bytes);

    h.state_mut().update(Msg::SetMetric(CostMetric::Rows));
    let rows = frame(&mut h);
    assert!(
        diff(&initial, &rows) > 100,
        "cost heat and labels visibly change"
    );
    assert_eq!(h.state().flow_scene().generation(), generation);
    assert_eq!(
        bytes(),
        initial_bytes,
        "metric overlay cannot rebuild GPU geometry"
    );

    h.state_mut().update(Msg::Pan(egui::vec2(23.0, 11.0)));
    let panned = frame(&mut h);
    assert!(diff(&rows, &panned) > 100);
    assert_eq!(bytes(), initial_bytes, "navigation only changes uniforms");

    h.state_mut().update(Msg::ToggleGroup("1".into()));
    let collapsed = frame(&mut h);
    assert!(
        diff(&panned, &collapsed) > 100,
        "collapsed group must reach framebuffer"
    );
    assert_ne!(h.state().flow_scene().generation(), generation);
    assert!(
        bytes() > initial_bytes,
        "changed topology must upload new geometry"
    );
    assert_eq!(
        gpu::residency(&rs),
        targets,
        "collapse reuses offscreen target"
    );
    let collapsed_bytes = bytes();
    frame(&mut h);
    assert_eq!(
        bytes(),
        collapsed_bytes,
        "collapsed topology remains resident"
    );
    gpu::evict_idle(&rs, u64::MAX);
    assert_eq!(gpu::residency(&rs).0, 0);
}

#[test]
fn canonical_plandag_golden() {
    if !enabled() {
        return;
    }
    let _turn = facett_core::render::gputurn::hold();
    let (mut h, _) = harness();
    frame(&mut h);
    frame(&mut h);
    let actual = frame(&mut h);
    let path =
        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/snapshots/flow_gpu.png");
    facett_core::golden::assert_golden_within(&actual, &path, "plandag_flow_gpu", 2);
}