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
135
136
137
138
139
140
141
142
143
144
145

//! Instanced column overlay layer.

use std::any::Any;

use super::{ColorRamp, ColumnInstanceSet};
use crate::layer::{Layer, LayerId, LayerKind};

/// An instanced column overlay layer.
///
/// Renders a collection of box or cylinder columns anchored to
/// geographic positions. Each column has independent height, width,
/// colour, and pick ID. Renderers use GPU instancing for efficient
/// draw of large datasets.
#[derive(Debug, Clone)]
pub struct InstancedColumnLayer {
    id: LayerId,
    name: String,
    visible: bool,
    opacity: f32,
    z_index: i32,
    /// Column instances.
    pub columns: ColumnInstanceSet,
    /// Fallback colour ramp for columns without per-instance colour.
    pub ramp: ColorRamp,
}

impl InstancedColumnLayer {
    /// Create a new instanced column layer.
    pub fn new(name: impl Into<String>, columns: ColumnInstanceSet, ramp: ColorRamp) -> Self {
        Self {
            id: LayerId::next(),
            name: name.into(),
            visible: true,
            opacity: 1.0,
            z_index: 0,
            columns,
            ramp,
        }
    }

    /// Replace the column set.
    pub fn set_columns(&mut self, columns: ColumnInstanceSet) {
        self.columns = columns;
    }
}

impl Layer for InstancedColumnLayer {
    fn id(&self) -> LayerId {
        self.id
    }

    fn name(&self) -> &str {
        &self.name
    }

    fn kind(&self) -> LayerKind {
        LayerKind::Visualization
    }

    fn visible(&self) -> bool {
        self.visible
    }

    fn set_visible(&mut self, visible: bool) {
        self.visible = visible;
    }

    fn opacity(&self) -> f32 {
        self.opacity
    }

    fn set_opacity(&mut self, opacity: f32) {
        self.opacity = opacity.clamp(0.0, 1.0);
    }

    fn z_index(&self) -> i32 {
        self.z_index
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::visualization::{ColorStop, ColumnInstance};
    use rustial_math::GeoCoord;

    fn test_ramp() -> ColorRamp {
        ColorRamp::new(vec![
            ColorStop {
                value: 0.0,
                color: [0.0, 0.0, 1.0, 1.0],
            },
            ColorStop {
                value: 1.0,
                color: [1.0, 0.0, 0.0, 1.0],
            },
        ])
    }

    #[test]
    fn instanced_column_layer_basics() {
        let columns = ColumnInstanceSet::new(vec![ColumnInstance::new(
            GeoCoord::from_lat_lon(0.0, 0.0),
            100.0,
            10.0,
        )
        .with_pick_id(1)]);
        let layer = InstancedColumnLayer::new("histogram", columns, test_ramp());
        assert_eq!(layer.name(), "histogram");
        assert_eq!(layer.columns.len(), 1);
        assert_eq!(layer.columns.columns[0].pick_id, 1);
    }

    #[test]
    fn instanced_column_layer_downcast() {
        let columns = ColumnInstanceSet::default();
        let layer: Box<dyn Layer> =
            Box::new(InstancedColumnLayer::new("test", columns, test_ramp()));
        assert!(layer
            .as_any()
            .downcast_ref::<InstancedColumnLayer>()
            .is_some());
    }

    #[test]
    fn set_columns_replaces() {
        let mut layer =
            InstancedColumnLayer::new("test", ColumnInstanceSet::default(), test_ramp());
        assert!(layer.columns.is_empty());
        layer.set_columns(ColumnInstanceSet::new(vec![ColumnInstance::new(
            GeoCoord::from_lat_lon(0.0, 0.0),
            50.0,
            5.0,
        )]));
        assert_eq!(layer.columns.len(), 1);
    }
}