Merge pull request #112 from Maximkaaa/refactoring

Refactoring

galileo/src/layer/raster_tile_layer.rs

@@ -1,8 +1,7 @@
 use crate::decoded_image::DecodedImage;
 use crate::layer::data_provider::DataProvider;
 use crate::messenger::Messenger;
-use crate::render::render_bundle::RenderBundle;
-use crate::render::{Canvas, ImagePaint, PackedBundle, PrimitiveId, RenderOptions};
+use crate::render::{Canvas, ImagePaint, PackedBundle, RenderOptions};
 use crate::tile_scheme::{TileIndex, TileSchema};
 use crate::view::MapView;
 use galileo_types::cartesian::Size;
@@ -36,11 +35,15 @@ enum TileState {
 }
 
 struct RenderedTile {
-    render_bundle: RenderBundle,
     packed_bundle: Box<dyn PackedBundle>,
     first_drawn: SystemTime,
-    is_opaque: bool,
-    primitive_id: PrimitiveId,
+    opacity: f32,
+}
+
+impl RenderedTile {
+    fn is_opaque(&self) -> bool {
+        self.opacity > 0.999
+    }
 }
 
 impl<Provider> RasterTileLayer<Provider>
@@ -82,7 +85,7 @@ where
                 None => to_substitute.push(index),
                 Some(tile_state) => match &*tile_state.clone() {
                     TileState::Rendered(tile) => {
-                        if !tile.lock().is_opaque {
+                        if !tile.lock().is_opaque() {
                             to_substitute.push(index);
                         }
 
@@ -124,7 +127,7 @@ where
                             .as_ref()
                             .map(|v| v.as_ref())
                         {
-                            if !rendered.lock().is_opaque {
+                            if !rendered.lock().is_opaque() {
                                 need_more = true;
                             }
                         }
@@ -172,38 +175,26 @@ where
             match &**tile {
                 TileState::Rendered(rendered) => {
                     let mut rendered = rendered.lock();
-                    if rendered.is_opaque {
+                    if rendered.is_opaque() {
                         continue;
                     }
 
                     let first_drawn = rendered.first_drawn;
-                    let primitive_id = rendered.primitive_id;
 
                     let since_drawn = now
                         .duration_since(first_drawn)
                         .unwrap_or(Duration::from_millis(0));
                     let opacity = if self.fade_in_duration.is_zero() {
-                        255
+                        0.0
                     } else {
-                        ((since_drawn.as_secs_f64() / self.fade_in_duration.as_secs_f64()).min(1.0)
-                            * 255.0) as u8
+                        (since_drawn.as_secs_f64() / self.fade_in_duration.as_secs_f64()).min(1.0)
+                            as f32
                     };
 
-                    let is_opaque = opacity == 255;
-                    if !is_opaque {
+                    rendered.opacity = opacity;
+                    if !rendered.is_opaque() {
                         requires_redraw = true;
                     }
-
-                    if let Err(err) = rendered
-                        .render_bundle
-                        .modify_image(primitive_id, ImagePaint { opacity })
-                    {
-                        log::warn!("Failed to update image style: {err}");
-                    }
-
-                    let packed = canvas.pack_bundle(&rendered.render_bundle);
-                    rendered.packed_bundle = packed;
-                    rendered.is_opaque = is_opaque;
                 }
                 TileState::Loaded(decoded_image) => {
                     let mut bundle = canvas.create_bundle();
@@ -216,30 +207,28 @@ where
                     );
 
                     let opacity = if self.fade_in_duration.is_zero() {
-                        255
+                        1.0
                     } else {
-                        0
+                        0.0
                     };
 
                     let Some(tile_bbox) = self.tile_scheme.tile_bbox(*index) else {
                         log::warn!("Failed to get bbox for tile {index:?}");
                         continue;
                     };
 
-                    let id = bundle.add_image(
+                    bundle.add_image(
                         owned,
                         tile_bbox.into_quadrangle(),
-                        ImagePaint { opacity },
+                        ImagePaint { opacity: 255 },
                     );
                     let packed = canvas.pack_bundle(&bundle);
                     self.tiles.insert(
                         *index,
                         Arc::new(TileState::Rendered(Box::new(Mutex::new(RenderedTile {
-                            render_bundle: bundle,
                             packed_bundle: packed,
                             first_drawn: now,
-                            is_opaque: false,
-                            primitive_id: id,
+                            opacity,
                         })))),
                     );
 
@@ -323,10 +312,10 @@ where
             }
         }
 
-        canvas.draw_bundles(
+        canvas.draw_bundles_with_opacity(
             &to_draw
                 .iter()
-                .map(|guard| &*guard.packed_bundle)
+                .map(|guard| (&*guard.packed_bundle, guard.opacity))
                 .collect::<Vec<_>>(),
             RenderOptions::default(),
         );

galileo/src/layer/vector_tile_layer/mod.rs

@@ -1,7 +1,6 @@
 //! [Vector tile layers](VectorTileLayer) load prepared vector tiles using a [data provider](VectorTileProviderT)
 //! and draw them to the map with the given [`VectorTileStyle`].
 
-use maybe_sync::{MaybeSend, MaybeSync};
 use std::any::Any;
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -14,8 +13,6 @@ use galileo_types::geometry::CartesianGeometry2d;
 pub use vector_tile::VectorTile;
 
 use crate::layer::vector_tile_layer::style::VectorTileStyle;
-use crate::layer::vector_tile_layer::tile_provider::loader::VectorTileLoader;
-use crate::layer::vector_tile_layer::tile_provider::processor::VectorTileProcessor;
 use crate::layer::vector_tile_layer::tile_provider::{VectorTileProvider, VtStyleId};
 use crate::layer::Layer;
 use crate::messenger::Messenger;
@@ -29,21 +26,13 @@ mod vector_tile;
 
 /// Vector tile layers use [`Providers`](VectorTileProviderT) to load prepared vector tiles, and then render them using
 /// specified [styles](VectorTileStyle).
-pub struct VectorTileLayer<Loader, Processor>
-where
-    Loader: VectorTileLoader + MaybeSend + MaybeSync + 'static,
-    Processor: VectorTileProcessor + MaybeSend + MaybeSync + 'static,
-{
-    tile_provider: VectorTileProvider<Loader, Processor>,
+pub struct VectorTileLayer {
+    tile_provider: VectorTileProvider,
     tile_scheme: TileSchema,
     style_id: VtStyleId,
 }
 
-impl<Loader, Processor> Layer for VectorTileLayer<Loader, Processor>
-where
-    Loader: VectorTileLoader + MaybeSend + MaybeSync + 'static,
-    Processor: VectorTileProcessor + MaybeSend + MaybeSync + 'static,
-{
+impl Layer for VectorTileLayer {
     fn render(&self, view: &MapView, canvas: &mut dyn Canvas) {
         let tiles = self.get_tiles_to_draw(view, canvas);
         let to_render: Vec<&dyn PackedBundle> = tiles.iter().map(|v| &**v).collect();
@@ -72,11 +61,7 @@ where
     }
 }
 
-impl<Loader, Processor> VectorTileLayer<Loader, Processor>
-where
-    Loader: VectorTileLoader + MaybeSend + MaybeSync + 'static,
-    Processor: VectorTileProcessor + MaybeSend + MaybeSync + 'static,
-{
+impl VectorTileLayer {
     /// Style of the layer.
     pub fn style(&self) -> Arc<VectorTileStyle> {
         self.tile_provider
@@ -86,7 +71,7 @@ where
 
     /// Creates a new layer with the given url source.
     pub fn from_url(
-        mut tile_provider: VectorTileProvider<Loader, Processor>,
+        mut tile_provider: VectorTileProvider,
         style: VectorTileStyle,
         tile_scheme: TileSchema,
     ) -> Self {
@@ -143,6 +128,7 @@ where
     /// Change style of the layer and redraw it.
     pub fn update_style(&mut self, style: VectorTileStyle) {
         let new_style_id = self.tile_provider.add_style(style);
+        self.tile_provider.drop_style(self.style_id);
         self.style_id = new_style_id;
     }
 
@@ -202,3 +188,46 @@ where
         features
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        platform::native::vt_processor::ThreadVtProcessor,
+        render::render_bundle::{
+            tessellating::TessellatingRenderBundle, RenderBundle, RenderBundleType,
+        },
+        tests::TestTileLoader,
+    };
+
+    use super::*;
+
+    fn test_layer() -> VectorTileLayer {
+        let tile_schema = TileSchema::web(18);
+        let empty_bundle = RenderBundle(RenderBundleType::Tessellating(
+            TessellatingRenderBundle::new(),
+        ));
+        let mut provider = VectorTileProvider::new(
+            Arc::new(TestTileLoader {}),
+            Arc::new(ThreadVtProcessor::new(tile_schema.clone(), empty_bundle)),
+        );
+
+        let style_id = provider.add_style(VectorTileStyle::default());
+        VectorTileLayer {
+            tile_provider: provider,
+            tile_scheme: TileSchema::web(18),
+            style_id,
+        }
+    }
+
+    #[test]
+    fn update_style_drops_previous_style() {
+        let mut layer = test_layer();
+        let style_id = layer.style_id;
+        assert!(layer.tile_provider.get_style(style_id).is_some());
+
+        layer.update_style(VectorTileStyle::default());
+        let new_style_id = layer.style_id;
+        assert!(layer.tile_provider.get_style(new_style_id).is_some());
+        assert!(layer.tile_provider.get_style(style_id).is_none());
+    }
+}

galileo/src/layer/vector_tile_layer/tile_provider/loader.rs

@@ -21,7 +21,7 @@ pub enum TileLoadError {
 /// Loader for vector tiles.
 #[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
-pub trait VectorTileLoader {
+pub trait VectorTileLoader: MaybeSend + MaybeSync {
     /// Load tile with the given index.
     async fn load(&self, index: TileIndex) -> Result<MvtTile, TileLoadError>;
 }