sinomo-ui-render-wgpu 0.3.0

wgpu renderer boundary for SUI scene frames.
Documentation
use crate::WgpuRenderer;
use crate::tests::support::assert_rgba_images_match;
use sui_core::{Color, Path, Point, Rect, Size, Vector, WidgetId, WindowId};
use sui_scene::{
    LayerProperties, Scene, SceneCommand, SceneFrame, SceneLayer, SceneLayerDescriptor,
    SceneLayerId,
};

fn layered_frame(window: WindowId, revision: usize) -> SceneFrame {
    let mut frame = SceneFrame::new(window, Size::new(200.0, 140.0));
    frame.scene.push(SceneCommand::Clear(Color::BLACK));
    frame.scene.push(SceneCommand::PushClip {
        rect: Rect::new(0.0, 0.0, if revision == 4 { 100.0 } else { 200.0 }, 140.0),
    });
    let mut content = Scene::new();
    for index in 0..80 {
        content.push(SceneCommand::FillRoundedRect {
            rect: Rect::new(
                (index % 10) as f32 * 18.0,
                (index / 10) as f32 * 16.0,
                12.0,
                12.0,
            ),
            radii: [3.0; 4],
            brush: if revision == 1 && index == 20 {
                Color::WHITE
            } else {
                Color::rgba(0.2, 0.5, 0.8, 1.0)
            }
            .into(),
            border: None,
            shadow: None,
        });
    }
    let owner = WidgetId::new(9201);
    let mut descriptor = SceneLayerDescriptor::new(
        SceneLayerId::from_widget(owner),
        owner,
        Rect::new(0.0, 0.0, 180.0, 128.0),
    );
    descriptor.properties = LayerProperties {
        translation: if revision == 2 {
            Vector::new(7.0, 3.0)
        } else {
            Vector::ZERO
        },
        opacity: if revision == 3 { 0.4 } else { 1.0 },
    };
    frame
        .scene
        .push(SceneCommand::Layer(SceneLayer::from_descriptor(
            descriptor, content,
        )));
    frame.scene.push(SceneCommand::PopClip);
    if revision == 5 {
        frame.scale_factor = 1.5;
        frame.surface_size = Size::new(300.0, 210.0);
    }
    frame
}

#[test]
fn prepared_fragments_reuse_unchanged_data_and_invalidate_local_edits_and_properties() {
    let window = WindowId::new(9200);
    let mut retained = WgpuRenderer::new();
    let mut reference = WgpuRenderer::new();
    for revision in [0, 0, 1, 2, 3, 4, 5, 0] {
        let frame = layered_frame(window, revision);
        retained.render(&frame).unwrap();
        let stats = retained.last_frame_stats(window).unwrap();
        if revision == 1 {
            assert_eq!(
                stats.prepared_fragment_build_count, 1,
                "one edited packet should be prepared"
            );
            assert!(stats.prepared_fragment_cache_hits >= 4);
        }
        reference.compositors.remove(&window);
        reference.frame_resources.fragments.remove(&window);
        reference.render(&frame).unwrap();
        assert_rgba_images_match(
            &reference.capture_rgba(window).unwrap(),
            &retained.capture_rgba(window).unwrap(),
        );
        retained.render(&frame).unwrap();
        let warm = retained.last_frame_stats(window).unwrap();
        assert_eq!(warm.prepared_fragment_build_count, 0);
        assert_eq!(warm.prepared_fragment_cache_hits, warm.direct_packet_count);
        assert_eq!(warm.uploaded_vertex_bytes, 0);
    }
    retained
        .render(&SceneFrame::new(window, Size::new(200.0, 140.0)))
        .unwrap();
    assert!(retained.frame_resources.fragments[&window].is_empty());
    retained.remove_window(window);
    assert!(!retained.frame_resources.fragments.contains_key(&window));
}

#[test]
fn prepared_analytic_instances_refresh_after_arena_slot_remapping() {
    let mut renderer = WgpuRenderer::new();
    let make_frame = |window, radius| {
        let mut frame = SceneFrame::new(window, Size::new(100.0, 100.0));
        frame.scene.push(SceneCommand::Clear(Color::BLACK));
        frame.scene.push(SceneCommand::FillPath {
            path: Path::circle(Point::new(50.0, 50.0), radius),
            brush: Color::WHITE.into(),
        });
        frame
    };
    renderer
        .render(&make_frame(WindowId::new(9210), 10.0))
        .unwrap();
    let window = WindowId::new(9211);
    let frame = make_frame(window, 30.0);
    renderer.render(&frame).unwrap();
    let expected = renderer.capture_rgba(window).unwrap();
    let signature = renderer
        .analytic_path_cache
        .iter()
        .find(|(_, entry)| entry.slot == 1)
        .map(|(signature, _)| *signature)
        .expect("second path occupies slot one");
    // Reproduce compaction after an unrelated cached path is retired.
    renderer
        .analytic_path_cache
        .retain(|key, _| *key == signature);
    renderer.frame_resources.analytic_path_arena.bind_group = None;
    renderer.render(&frame).unwrap();
    assert_eq!(renderer.analytic_path_cache[&signature].slot, 0);
    let stats = renderer.last_frame_stats(window).unwrap();
    assert_eq!(
        stats.retained_packet_build_count, 0,
        "raster content was unchanged"
    );
    assert_eq!(
        stats.prepared_fragment_build_count, 1,
        "GPU slot references must refresh"
    );
    assert_rgba_images_match(&expected, &renderer.capture_rgba(window).unwrap());
}

#[test]
fn snapshot_spans_replay_only_the_animated_layer_and_release_removed_content() {
    let window = WindowId::new(9220);
    let owner = WidgetId::new(9221);
    let mut renderer = WgpuRenderer::new();
    let mut reference = WgpuRenderer::new();
    reference
        .compositors
        .entry(window)
        .or_default()
        .snapshot_cache_enabled = false;
    for index in 0..24 {
        let mut frame = layered_frame(window, 0);
        let mut particles = Scene::new();
        for particle in 0..3 {
            particles.push(SceneCommand::FillRoundedRect {
                rect: Rect::new(10.0 + index as f32 + particle as f32 * 20.0, 50.0, 4.8, 4.8),
                radii: [2.4; 4],
                brush: Color::WHITE.into(),
                border: None,
                shadow: None,
            });
        }
        frame
            .scene
            .push(SceneCommand::Layer(SceneLayer::from_descriptor(
                SceneLayerDescriptor::new(
                    SceneLayerId::from_widget(owner),
                    owner,
                    Rect::new(0.0, 0.0, 200.0, 140.0),
                ),
                particles,
            )));
        renderer.render(&frame).unwrap();
        if index > 0 {
            let stats = renderer.last_frame_stats(window).unwrap();
            assert!(stats.snapshot_commands_reused >= 80);
            assert!(
                stats.snapshot_commands_replayed <= 6,
                "stationary content was replayed: {stats:?}"
            );
            assert_eq!(stats.prepared_fragment_build_count, 1);
        }
        if index == 1 || index == 23 {
            reference.render(&frame).unwrap();
            assert_rgba_images_match(
                &reference.capture_rgba(window).unwrap(),
                &renderer.capture_rgba(window).unwrap(),
            );
        }
        assert!(renderer.compositors[&window].snapshot_cache_len() <= 5);
    }
    renderer
        .render(&SceneFrame::new(window, Size::new(200.0, 140.0)))
        .unwrap();
    assert_eq!(renderer.compositors[&window].snapshot_cache_len(), 0);
}

#[test]
fn snapshot_span_fallback_matches_uncached_ancestor_changes_and_node_ids() {
    let window = WindowId::new(9222);
    let mut renderer = WgpuRenderer::new();
    let mut reference = WgpuRenderer::new();
    reference
        .compositors
        .entry(window)
        .or_default()
        .snapshot_cache_enabled = false;
    for revision in [0, 0, 2, 3, 4, 5, 1, 0] {
        let mut frame = layered_frame(window, revision);
        let mut prefix = Scene::new();
        // Changing the number of ancestors changes property-node allocation
        // and must invalidate spans even when their own commands are identical.
        if revision % 2 == 1 {
            prefix.push(SceneCommand::PushTransform {
                transform: sui_core::Transform::translation(0.5, 0.75),
            });
        }
        prefix.append(frame.scene);
        if revision % 2 == 1 {
            prefix.push(SceneCommand::PopTransform);
        }
        frame.scene = prefix;
        for _ in 0..2 {
            renderer.render(&frame).unwrap();
            reference.render(&frame).unwrap();
            assert_rgba_images_match(
                &reference.capture_rgba(window).unwrap(),
                &renderer.capture_rgba(window).unwrap(),
            );
        }
    }
}

#[test]
fn snapshot_spans_resume_reuse_after_geometry_stops_changing() {
    let window = WindowId::new(9224);
    let mut renderer = WgpuRenderer::new();
    renderer.render(&layered_frame(window, 0)).unwrap();
    let changed = layered_frame(window, 1);
    for _ in 0..10 {
        renderer.render(&changed).unwrap();
    }
    let stats = renderer.last_frame_stats(window).unwrap();
    assert!(stats.snapshot_commands_reused >= 80);
    assert_eq!(stats.prepared_fragment_build_count, 0);
}