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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::rc::Rc;

use cranpose_ui::Brush;
use cranpose_ui_graphics::{Color, TransformOrigin};

use super::*;

#[test]
fn apply_layer_to_rect_rotates_around_center() {
    let rect = Rect {
        x: 0.0,
        y: 0.0,
        width: 100.0,
        height: 40.0,
    };
    let layer = GraphicsLayer {
        rotation_z: 90.0,
        ..Default::default()
    };

    let transformed = apply_layer_to_rect(rect, rect, &layer);
    assert!((transformed.width - 40.0).abs() < 0.01);
    assert!((transformed.height - 100.0).abs() < 0.01);
}

#[test]
fn apply_layer_to_rect_honors_transform_origin() {
    let rect = Rect {
        x: 0.0,
        y: 0.0,
        width: 100.0,
        height: 40.0,
    };
    let layer = GraphicsLayer {
        rotation_z: 90.0,
        transform_origin: TransformOrigin::new(0.0, 0.0),
        ..Default::default()
    };

    let transformed = apply_layer_to_rect(rect, rect, &layer);
    assert!((transformed.x + 40.0).abs() < 0.01);
    assert!((transformed.y - 0.0).abs() < 0.01);
}

#[test]
fn apply_layer_to_rect_camera_distance_changes_projection() {
    let rect = Rect {
        x: 0.0,
        y: 0.0,
        width: 100.0,
        height: 60.0,
    };
    let near_camera = GraphicsLayer {
        rotation_y: 25.0,
        camera_distance: 8.0,
        ..Default::default()
    };
    let far_camera = GraphicsLayer {
        rotation_y: 25.0,
        camera_distance: 24.0,
        ..Default::default()
    };

    let near = apply_layer_to_rect(rect, rect, &near_camera);
    let far = apply_layer_to_rect(rect, rect, &far_camera);
    let delta = (near.x - far.x).abs()
        + (near.y - far.y).abs()
        + (near.width - far.width).abs()
        + (near.height - far.height).abs();
    assert!(delta > 0.05);
}

#[test]
fn apply_draw_commands_scales_round_rect_radii_with_uniform_axis_scale() {
    let command = DrawCommand::Behind(Rc::new(
        |scope: &mut cranpose_ui_graphics::DrawScopeDefault| {
            scope.push_recorded(vec![DrawPrimitive::RoundRect {
                rect: Rect {
                    x: 0.0,
                    y: 0.0,
                    width: 80.0,
                    height: 40.0,
                },
                brush: Brush::solid(Color::BLACK),
                radii: CornerRadii::uniform(10.0),
                stroke: None,
            }]);
        },
    ));

    let layer = GraphicsLayer {
        alpha: 0.5,
        ..Default::default()
    };
    let mut scene = CompositorScene::new();
    let bounds = Rect {
        x: 0.0,
        y: 0.0,
        width: 80.0,
        height: 40.0,
    };
    apply_draw_commands(
        &[command],
        DrawPlacement::Behind,
        bounds,
        Size {
            width: 80.0,
            height: 40.0,
        },
        &layer,
        None,
        &mut scene,
    );

    scene.flush_loose();
    let run = &scene.runs[0];
    let record = run.tables().shapes.get(0).unwrap();
    assert_eq!(record.radii, [10.0; 4], "the record keeps the app's radii");
    assert_eq!(
        run.placement.offset,
        cranpose_ui_graphics::Point::new(0.0, 0.0)
    );
    assert!(
        (record.color[3] - 0.5).abs() < 1e-6,
        "a loose primitive carries the layer's paint in its brush"
    );
}