cranpose-render-wgpu 0.1.164

WGPU renderer backend for Cranpose
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use cranpose_render_common::graph::{ProjectiveTransform, RenderNode};
use cranpose_ui_graphics::{Color, GraphicsLayer, Rect, RenderEffect};

use crate::{shared_test_support, support};

#[test]
fn profiled_frames_keep_current_uniforms_and_geometry() {
    if std::env::var_os("CRANPOSE_FENCE_TEST_CHILD").is_none() {
        let test_path = concat!(
            module_path!(),
            "::profiled_frames_keep_current_uniforms_and_geometry"
        );
        let test_name = test_path
            .split_once("::")
            .map_or(test_path, |(_, name)| name);
        for mode in ["off", "frame", "1"] {
            let mut command = std::process::Command::new(
                std::env::current_exe().expect("resolve the running test binary"),
            );
            command
                .args(["--exact", test_name, "--nocapture"])
                .env("CRANPOSE_FENCE_TEST_CHILD", mode);
            if mode == "off" {
                command.env_remove("CRANPOSE_GPU_FENCE_PROFILE");
            } else {
                command.env("CRANPOSE_GPU_FENCE_PROFILE", mode);
            }
            let result = command.output().expect("run isolated fence mode");
            let stdout = String::from_utf8_lossy(&result.stdout);
            assert!(
                result.status.success() && stdout.contains("1 passed"),
                "mode {mode} must run the test once and pass:\n{stdout}\n{}",
                String::from_utf8_lossy(&result.stderr)
            );
        }
        return;
    }
    let mut renderer = support::headless_renderer().expect("headless renderer");
    let bounds = Rect {
        x: 0.0,
        y: 0.0,
        width: 40.0,
        height: 40.0,
    };
    for frame in 0..6 {
        let color = if frame % 2 == 0 {
            Color::RED
        } else {
            Color::GREEN
        };
        let mut children = Vec::new();
        for column in 0..3 {
            children.push(RenderNode::Layer(Box::new(
                shared_test_support::layer_node(
                    bounds,
                    ProjectiveTransform::translation(
                        8.0 + column as f32 * 48.0,
                        8.0 + frame as f32,
                    ),
                    GraphicsLayer {
                        render_effect: Some(RenderEffect::blur(2.0 + column as f32)),
                        ..Default::default()
                    },
                    vec![support::solid_rect(bounds, color)],
                ),
            )));
        }
        let pixels = support::present_and_read(
            &mut renderer,
            160,
            64,
            support::page_graph(160, 64, children),
        );
        for column in 0..3 {
            let offset = ((28 + frame) * 160 + 28 + column * 48) * 4;
            let rgb = [pixels[offset + 2], pixels[offset + 1], pixels[offset]];
            let channel = frame % 2;
            assert!(
                rgb[channel] > 240 && rgb[1 - channel] < 10 && rgb[2] < 10,
                "frame {frame}, tile {column}: current color disappeared or used stale uploads: {rgb:?}"
            );
        }
    }
}