fix(regression): Fix raster tiles fade in setting

Fix configuring fade in duration for raster tile layers.

Author: Maximkaaa

galileo/src/layer/raster_tile_layer/mod.rs

@@ -26,7 +26,6 @@ pub struct RasterTileLayer {
     tile_loader: Arc<dyn RasterTileLoader>,
     tile_container: Arc<TilesContainer<(), RasterTileProvider>>,
     tile_schema: TileSchema,
-    fade_in_duration: Duration,
     messenger: Option<Arc<dyn Messenger>>,
     attribution: Option<Attribution>,
 }
@@ -35,13 +34,12 @@ impl std::fmt::Debug for RasterTileLayer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("RasterTileLayer")
             .field("tile_schema", &self.tile_schema)
-            .field("fade_in_duration", &self.fade_in_duration)
             .finish()
     }
 }
 
 impl RasterTileLayer {
-    /// Creates anew layer.
+    /// Creates a new layer.
     pub fn new(
         tile_schema: TileSchema,
         tile_loader: impl RasterTileLoader + 'static,
@@ -54,7 +52,6 @@ impl RasterTileLayer {
                 RasterTileProvider::new(tile_schema.clone()),
             )),
             tile_schema,
-            fade_in_duration: Duration::from_millis(300),
             messenger,
             attribution: None,
         }
@@ -73,15 +70,14 @@ impl RasterTileLayer {
                 RasterTileProvider::new(tile_schema.clone()),
             )),
             tile_schema,
-            fade_in_duration: Duration::from_millis(300),
             messenger: messenger.map(|m| m.into()),
             attribution,
         }
     }
 
     /// Sets fade in duration for newly loaded tiles.
     pub fn set_fade_in_duration(&mut self, duration: Duration) {
-        self.fade_in_duration = duration;
+        self.tile_container.set_fade_in_duration(duration);
     }
 
     fn update_displayed_tiles(&self, view: &MapView, canvas: &dyn Canvas) {
@@ -168,6 +164,7 @@ impl Layer for RasterTileLayer {
             .filter_map(|v| {
                 let tile_bbox = self.tile_schema.tile_bbox(v.index)?;
                 let offset = Vector2::new(tile_bbox.x_min() as f32, tile_bbox.y_max() as f32);
+
                 Some(BundleToDraw::new(&*v.bundle, v.opacity, offset))
             })
             .collect();

galileo/src/layer/tiles.rs

@@ -1,3 +1,4 @@
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -7,6 +8,8 @@ use crate::render::PackedBundle;
 use crate::tile_schema::{TileIndex, WrappingTileIndex};
 use crate::TileSchema;
 
+const DEFAULT_FADE_IN_DURATION: Duration = Duration::from_millis(300);
+
 #[derive(Clone)]
 pub(crate) struct DisplayedTile<StyleId: Copy> {
     pub(crate) index: WrappingTileIndex,
@@ -34,6 +37,7 @@ where
     pub(crate) tiles: Mutex<Vec<DisplayedTile<StyleId>>>,
     tile_schema: TileSchema,
     pub(crate) tile_provider: Provider,
+    pub fade_in_duration: AtomicU64,
 }
 
 impl<StyleId, Provider> TilesContainer<StyleId, Provider>
@@ -46,6 +50,7 @@ where
             tiles: Default::default(),
             tile_schema,
             tile_provider,
+            fade_in_duration: AtomicU64::new(DEFAULT_FADE_IN_DURATION.as_millis() as u64),
         }
     }
 
@@ -60,7 +65,7 @@ where
         let mut to_substitute = vec![];
 
         let now = web_time::Instant::now();
-        let fade_in_time = self.fade_in_time();
+        let fade_in_time = self.fade_in_duration();
         let mut requires_redraw = false;
 
         for index in needed_indices {
@@ -70,9 +75,13 @@ where
             {
                 if !displayed.is_opaque() {
                     to_substitute.push(index);
-                    displayed.opacity = ((now.duration_since(displayed.displayed_at)).as_secs_f64()
-                        / fade_in_time.as_secs_f64())
-                    .min(1.0) as f32;
+                    let fade_in_secs = fade_in_time.as_secs_f64();
+                    displayed.opacity = if fade_in_secs > 0.001 {
+                        ((now.duration_since(displayed.displayed_at)).as_secs_f64() / fade_in_secs)
+                            .min(1.0) as f32
+                    } else {
+                        1.0
+                    };
                     requires_redraw = true;
                 }
 
@@ -81,11 +90,12 @@ where
                 match self.tile_provider.get_tile(index.into(), style_id) {
                     None => to_substitute.push(index),
                     Some(bundle) => {
+                        let opacity = if self.requires_animation() { 0.0 } else { 1.0 };
                         needed_tiles.push(DisplayedTile {
                             index,
                             bundle,
                             style_id,
-                            opacity: 0.0,
+                            opacity,
                             displayed_at: now,
                         });
                         to_substitute.push(index);
@@ -126,7 +136,16 @@ where
         requires_redraw
     }
 
-    fn fade_in_time(&self) -> Duration {
-        Duration::from_millis(300)
+    pub fn fade_in_duration(&self) -> Duration {
+        Duration::from_millis(self.fade_in_duration.load(Ordering::Relaxed))
+    }
+
+    pub fn set_fade_in_duration(&self, duration: Duration) {
+        self.fade_in_duration
+            .store(duration.as_millis() as u64, Ordering::Relaxed);
+    }
+
+    fn requires_animation(&self) -> bool {
+        self.fade_in_duration.load(Ordering::Relaxed) > 1
     }
 }