molgfx-render 0.1.0

The render graph, passes and the engine that drives a frame.
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

use super::*;

fn row(active: bool) -> PackedPrimitive {
    let mut motion = ParticleMotionGpu::default();
    motion.metadata[0] = u32::from(active);
    PackedPrimitive::new(PrimitiveGpu::default(), motion)
}

fn shaped(family: u32, shape: u32, alpha: f32) -> PackedPrimitive {
    let mut record = PrimitiveGpu::default();
    record.metadata[2] = family;
    record.metadata[3] = shape;
    record.color[3] = alpha;
    PackedPrimitive::new(record, ParticleMotionGpu::default())
}

#[test]
fn static_tables_omit_per_primitive_auxiliary_columns() {
    let mut rows = [row(false), row(false)];
    let mut records = Vec::new();
    let mut previous = Vec::new();
    let mut motion = Vec::new();
    let mut groups = Vec::new();

    regroup(
        &mut rows,
        &mut records,
        &mut previous,
        &mut motion,
        &mut groups,
        false,
    );

    assert_eq!(records.len(), 2);
    assert!(previous.is_empty());
    assert!(motion.is_empty());
    assert_eq!(records[0].inverse_cross[3].to_bits(), 0.0_f32.to_bits());
}

#[test]
fn moving_tables_keep_lockstep_auxiliary_columns() {
    let mut rows = [row(false), row(true)];
    let mut records = Vec::new();
    let mut previous = Vec::new();
    let mut motion = Vec::new();
    let mut groups = Vec::new();

    regroup(
        &mut rows,
        &mut records,
        &mut previous,
        &mut motion,
        &mut groups,
        true,
    );

    assert_eq!(previous.len(), records.len());
    assert_eq!(motion.len(), records.len());
    assert_eq!(records[1].inverse_cross[3].to_bits(), 1.0_f32.to_bits());
}

#[test]
fn regroup_separates_polygon_sides_particle_shapes_and_transparency_ranges() {
    let mut rows = [
        shaped(FAMILY_POLYGON, 4, 1.0),
        shaped(FAMILY_PARTICLE, 4, 0.5),
        shaped(FAMILY_POLYGON, 1, 1.0),
        shaped(FAMILY_PARTICLE, 0, 1.0),
        shaped(FAMILY_POLYGON, 5, 1.0),
    ];
    let mut records = Vec::new();
    let mut previous = Vec::new();
    let mut motion = Vec::new();
    let mut groups = Vec::new();

    regroup(
        &mut rows,
        &mut records,
        &mut previous,
        &mut motion,
        &mut groups,
        false,
    );

    assert_eq!(
        groups,
        vec![
            PrimitiveDrawGroup {
                family: FAMILY_POLYGON,
                shape: POLYGON_PENTAGON,
                translucent: false,
                first: 0,
                len: 2,
            },
            PrimitiveDrawGroup {
                family: FAMILY_POLYGON,
                shape: POLYGON_HEXAGON,
                translucent: false,
                first: 2,
                len: 1,
            },
            PrimitiveDrawGroup {
                family: FAMILY_PARTICLE,
                shape: 0,
                translucent: false,
                first: 3,
                len: 1,
            },
            PrimitiveDrawGroup {
                family: FAMILY_PARTICLE,
                shape: 4,
                translucent: true,
                first: 4,
                len: 1,
            },
        ]
    );
}