molgfx-core 0.3.5

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

impl Timeline {
    /// Binds two source-aligned point frames for GPU interpolation.
    ///
    /// # Errors
    ///
    /// Returns a typed error for stale, non-finite, mismatched or duplicate input.
    pub fn bind_points(
        &mut self,
        scene: &mut Scene,
        batch: crate::PointBatchHandle,
        start: Arc<[[f32; 3]]>,
        end: Arc<[[f32; 3]]>,
        warp: TimeWarp,
    ) -> Result<TimelineTrackHandle, CoreError> {
        if self
            .tracks
            .iter()
            .any(|(_, track)| track.targets_points(batch))
        {
            return Err(invalid("a point batch may have only one timeline track"));
        }
        scene.bind_point_frames(batch, start, end)?;
        Ok(TimelineTrackHandle(
            self.tracks.insert(TimelineTrack::Points { batch, warp }),
        ))
    }

    /// Binds two source-aligned rigid-transform frames for GPU interpolation.
    ///
    /// # Errors
    ///
    /// Returns a typed error for a stale batch, mismatched row counts or a
    /// second timeline targeting the same batch.
    pub fn bind_instances(
        &mut self,
        scene: &mut Scene,
        batch: InstanceBatchHandle,
        start: Arc<[crate::RigidInstance]>,
        end: Arc<[crate::RigidInstance]>,
        warp: TimeWarp,
    ) -> Result<TimelineTrackHandle, CoreError> {
        if self
            .tracks
            .iter()
            .any(|(_, track)| track.targets_instances(batch))
        {
            return Err(invalid(
                "an instance batch may have only one timeline track",
            ));
        }
        scene.bind_instance_frames(batch, start, end)?;
        Ok(TimelineTrackHandle(
            self.tracks.insert(TimelineTrack::Instances { batch, warp }),
        ))
    }

    /// Binds two scalar or vector attribute frames for GPU interpolation.
    ///
    /// # Errors
    ///
    /// Returns a typed error for a stale attribute, incompatible frames or a
    /// second timeline targeting the same attribute.
    pub fn bind_attribute(
        &mut self,
        scene: &mut Scene,
        attribute: AttributeHandle,
        start: AttributeValues,
        end: AttributeValues,
        warp: TimeWarp,
    ) -> Result<TimelineTrackHandle, CoreError> {
        if self
            .tracks
            .iter()
            .any(|(_, track)| track.targets_attribute(attribute))
        {
            return Err(invalid("an attribute may have only one timeline track"));
        }
        scene.bind_attribute_frames(attribute, start, end)?;
        Ok(TimelineTrackHandle(
            self.tracks
                .insert(TimelineTrack::Attribute { attribute, warp }),
        ))
    }

    /// Removes a track and releases any generic resident frame pair it owns.
    pub fn unbind(&mut self, scene: &mut Scene, handle: TimelineTrackHandle) -> bool {
        let Some(track) = self.tracks.remove(handle.0) else {
            return false;
        };
        match track {
            TimelineTrack::Points { batch, .. } => scene.unbind_point_frames(batch),
            TimelineTrack::Instances { batch, .. } => scene.unbind_instance_frames(batch),
            TimelineTrack::Attribute { attribute, .. } => {
                scene.unbind_attribute_frames(attribute);
            }
            TimelineTrack::Trajectory { .. }
            | TimelineTrack::BondTopology { .. }
            | TimelineTrack::AtomProperty { .. } => {}
        }
        self.revision = self.revision.wrapping_add(1);
        true
    }
}