molgfx-core 0.2.1

The semantic scene graph: columnar tables, GPU record layouts, the borrowed coordinate seam.
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

//! Bounded identity-table preparation for scene rehydration.

use super::{Scene, SceneDescription, invalid};
use crate::handle::SlotMap;

#[cfg(test)]
#[path = "rehydrate_rows_tests.rs"]
mod tests;

pub(super) fn prepare(
    scene: &mut Scene,
    description: &SceneDescription,
) -> Result<(), crate::CoreError> {
    prepare_table(
        &mut scene.structures,
        description.structures.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.selections,
        description.selections.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.properties,
        description.atom_properties.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.representations,
        description.representations.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.volumes,
        description.volumes.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.segmentations,
        description.segmentations.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.meshes,
        description.meshes.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.mesh_instances,
        description.mesh_instances.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.primitive,
        description.primitives.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.ligand_pose_batches,
        description
            .ligand_pose_batches
            .iter()
            .map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.point_batches,
        description.point_batches.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.instance_batches,
        description.instance_batches.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.attributes,
        description.attributes.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.relation_batches,
        description.relation_batches.iter().map(|value| value.row),
    )?;
    prepare_table(
        &mut scene.overlays,
        description.overlays.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.guides,
        description.guides.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.interactions,
        description.interactions.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.labels,
        description.annotations.iter().map(|value| value.row),
    )?;
    prepare_pickable_table(
        &mut scene.labels,
        description.measurements.iter().map(|value| value.row),
    )
}

fn prepare_pickable_table<T, I>(map: &mut SlotMap<T>, rows: I) -> Result<(), crate::CoreError>
where
    I: ExactSizeIterator<Item = u32> + Clone,
{
    if rows.clone().any(|row| row > crate::EntityId::MAX_INDEX) {
        return invalid("manifest row exceeds the picking identity range");
    }
    prepare_table(map, rows)
}

fn prepare_table<T, I>(map: &mut SlotMap<T>, rows: I) -> Result<(), crate::CoreError>
where
    I: ExactSizeIterator<Item = u32>,
{
    match map.prepare_manifest_rows(rows) {
        Ok(()) => Ok(()),
        Err(error) => invalid(error.reason()),
    }
}