molgfx-geometry 0.3.5

GPU geometry generation: impostor packing, cartoons, labels, bounding hierarchies.
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

use super::*;

/// A straight spine of unit-spaced samples.
fn spine(count: usize) -> Vec<Vec3> {
    let mut points = Vec::with_capacity(count);
    let mut x = 0.0f32;
    for _ in 0..count {
        points.push(Vec3::new(x, 0.0, 0.0));
        x += 1.0;
    }
    points
}

#[test]
fn a_neutral_layer_offsets_nothing() {
    let source = spine(40);
    let mut offsets = Vec::new();
    solve_offsets(&source, SecondaryMotion::default(), &mut offsets);
    assert_eq!(offsets.len(), source.len());
    assert!(
        offsets.iter().all(|offset| *offset == Vec3::ZERO),
        "an amplitude of zero contributes no displacement"
    );
}

#[test]
fn the_anchored_ends_stay_on_the_source_spine() {
    let source = spine(60);
    let mut offsets = Vec::new();
    solve_offsets(&source, SecondaryMotion::gentle(), &mut offsets);
    let Some(first) = offsets.first() else {
        panic!("one offset per sample")
    };
    let Some(last) = offsets.last() else {
        panic!("one offset per sample")
    };
    assert!(first.length() < 1.0e-5, "the first sample is anchored");
    assert!(last.length() < 1.0e-5, "the last sample is anchored");
    assert!(
        offsets.iter().any(|offset| offset.length() > 0.05),
        "the interior actually moves"
    );
}

#[test]
fn the_offset_is_transverse_and_bounded_by_the_amplitude() {
    let source = spine(60);
    let motion = SecondaryMotion {
        amplitude: 1.5,
        ..SecondaryMotion::gentle()
    };
    let mut offsets = Vec::new();
    solve_offsets(&source, motion, &mut offsets);
    for offset in &offsets {
        assert!(
            offset.length() <= motion.amplitude + 1.0e-3,
            "no sample exceeds the requested amplitude"
        );
        // The spine runs along x, so a follow-through must not stretch it.
        assert!(
            offset.x.abs() < 0.35,
            "displacement stays across the spine, got {offset:?}"
        );
    }
}

#[test]
fn the_same_spine_and_phase_resolve_identically() {
    let source = spine(48);
    let motion = SecondaryMotion {
        phase: 0.37,
        ..SecondaryMotion::gentle()
    };
    let mut first = Vec::new();
    let mut second = Vec::new();
    solve_offsets(&source, motion, &mut first);
    solve_offsets(&source, motion, &mut second);
    assert_eq!(first, second, "the solver carries no hidden state");
}

#[test]
fn malformed_settings_resolve_to_bounded_values() {
    let motion = SecondaryMotion {
        amplitude: f32::NAN,
        wavelength_samples: -3.0,
        phase: f32::INFINITY,
        iterations: 0,
        stiffness: 9.0,
        anchor_fraction: -1.0,
    }
    .sanitized();
    assert!(motion.wavelength_samples >= 2.0);
    assert!(motion.phase.is_finite());
    assert!(motion.iterations >= 1);
    assert!((0.0..=1.0).contains(&motion.stiffness));
    assert!((0.0..=0.5).contains(&motion.anchor_fraction));
    assert!(
        motion.is_neutral(),
        "a malformed amplitude contributes nothing"
    );
}