rustial-engine 0.0.1

Framework-agnostic 2.5D map engine for rustial
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Point-cloud / scatter descriptors.

use crate::models::AltitudeMode;
use rustial_math::GeoCoord;

/// A single point-cloud instance anchored to a geographic position.
#[derive(Debug, Clone)]
pub struct PointInstance {
    /// Geographic anchor position.
    pub position: GeoCoord,
    /// Point radius in meters.
    pub radius: f64,
    /// Intensity value used by fallback colour ramps.
    pub intensity: f32,
    /// Optional per-instance RGBA colour override.
    pub color: Option<[f32; 4]>,
    /// Stable pick identifier returned by the picking system.
    pub pick_id: u64,
    /// Altitude mode for this point.
    pub altitude_mode: AltitudeMode,
}

impl PointInstance {
    /// Create a point instance with the given position and radius.
    pub fn new(position: GeoCoord, radius: f64) -> Self {
        Self {
            position,
            radius,
            intensity: 1.0,
            color: None,
            pick_id: 0,
            altitude_mode: AltitudeMode::ClampToGround,
        }
    }

    /// Set the intensity.
    pub fn with_intensity(mut self, intensity: f32) -> Self {
        self.intensity = intensity;
        self
    }

    /// Set the pick id.
    pub fn with_pick_id(mut self, id: u64) -> Self {
        self.pick_id = id;
        self
    }

    /// Set an RGBA colour override.
    pub fn with_color(mut self, color: [f32; 4]) -> Self {
        self.color = Some(color);
        self
    }

    /// Set the altitude mode.
    pub fn with_altitude_mode(mut self, altitude_mode: AltitudeMode) -> Self {
        self.altitude_mode = altitude_mode;
        self
    }
}

/// A collection of [`PointInstance`]s with a generation counter.
#[derive(Debug, Clone)]
pub struct PointInstanceSet {
    /// The point instances.
    pub points: Vec<PointInstance>,
    /// Structural generation counter. Bump when the number or identity
    /// of points changes.
    pub generation: u64,
}

impl PointInstanceSet {
    /// Create a new set from existing points.
    pub fn new(points: Vec<PointInstance>) -> Self {
        Self {
            points,
            generation: 0,
        }
    }

    /// Number of points.
    #[inline]
    pub fn len(&self) -> usize {
        self.points.len()
    }

    /// Whether the set is empty.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.points.is_empty()
    }
}

impl Default for PointInstanceSet {
    fn default() -> Self {
        Self::new(Vec::new())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn point_instance_defaults() {
        let point = PointInstance::new(GeoCoord::from_lat_lon(0.0, 0.0), 4.0);
        assert!((point.radius - 4.0).abs() < 1e-9);
        assert!((point.intensity - 1.0).abs() < 1e-6);
        assert!(point.color.is_none());
        assert_eq!(point.pick_id, 0);
    }

    #[test]
    fn point_instance_builder() {
        let point = PointInstance::new(GeoCoord::from_lat_lon(0.0, 0.0), 2.5)
            .with_intensity(0.25)
            .with_pick_id(42)
            .with_color([1.0, 0.0, 0.0, 1.0])
            .with_altitude_mode(AltitudeMode::Absolute);
        assert_eq!(point.pick_id, 42);
        assert_eq!(point.color, Some([1.0, 0.0, 0.0, 1.0]));
        assert!((point.intensity - 0.25).abs() < 1e-6);
        assert_eq!(point.altitude_mode, AltitudeMode::Absolute);
    }

    #[test]
    fn point_instance_set_len() {
        let set = PointInstanceSet::new(vec![
            PointInstance::new(GeoCoord::from_lat_lon(0.0, 0.0), 2.0),
            PointInstance::new(GeoCoord::from_lat_lon(1.0, 1.0), 3.0),
        ]);
        assert_eq!(set.len(), 2);
        assert!(!set.is_empty());
    }
}