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

//! Dirty-state resolution for independent scientific property channels.

use molgfx_core::{
    AtomProperty, Representation, RowDomain, Scene, StructureHandle, VisualAttributeRef,
};

type Resolved<'a> = (Option<&'a AtomProperty>, Option<&'a AtomProperty>, [u64; 2]);

pub(super) type VisualResolved = ([Option<VisualAttributeRef>; 4], [u64; 4]);

pub(super) fn resolve<'a>(
    scene: &'a Scene,
    representation: &Representation,
    structure: StructureHandle,
) -> Resolved<'a> {
    let handles = [
        representation.color.property_handle(),
        representation
            .appearance
            .map(|appearance| appearance.property),
    ];
    let properties = handles
        .map(|handle| handle.and_then(|handle| scene.property_for_structure(handle, structure)));
    let revisions = handles.map(|handle| {
        handle
            .and_then(|handle| scene.property_content_revision(handle))
            .into_iter()
            .fold(0, |_, revision| revision)
    });
    (properties[0], properties[1], revisions)
}

pub(super) fn resolve_visual(
    scene: &Scene,
    representation: &Representation,
    structure: StructureHandle,
) -> VisualResolved {
    let handles = representation.visual.as_ref().map_or_else(
        || [None; 4],
        |style| {
            let mut handles = [None; 4];
            for (slot, handle) in style.program().attributes().iter().enumerate() {
                if slot == handles.len() {
                    break;
                }
                handles[slot] = Some(*handle);
            }
            handles
        },
    );
    let handles = handles.map(|handle| {
        handle.filter(|reference| match *reference {
            VisualAttributeRef::Attribute { handle, kind } => scene
                .attribute_for_domain(handle, RowDomain::Atoms(structure))
                .is_some_and(|attribute| attribute.kind() == kind),
            VisualAttributeRef::LegacyScalar(handle) => {
                scene.property_for_structure(handle, structure).is_some()
            }
            VisualAttributeRef::Column { .. } => false,
        })
    });
    let revisions = handles.map(|reference| match reference {
        Some(VisualAttributeRef::Attribute { handle, .. }) => {
            scene.attribute_change(handle).map_or(0, |change| change.0)
        }
        Some(VisualAttributeRef::LegacyScalar(handle)) => scene
            .property_content_revision(handle)
            .into_iter()
            .fold(0, |_, revision| revision),
        Some(VisualAttributeRef::Column { .. }) | None => 0,
    });
    (handles, revisions)
}