perf: Do not duplicate same vector tiles in GPU memory

Author: Maximkaaa

galileo/src/layer/raster_tile_layer/mod.rs

@@ -3,6 +3,7 @@
 use std::any::Any;
 use std::sync::Arc;
 
+use galileo_types::cartesian::Vector2;
 use provider::RasterTileProvider;
 use web_time::Duration;
 
@@ -89,9 +90,12 @@ impl RasterTileLayer {
         };
 
         let needed_indices: Vec<_> = tile_iter.collect();
+        let mut to_pack: Vec<TileIndex> = needed_indices.iter().map(|t| (*t).into()).collect();
+        to_pack.dedup();
+
         self.tile_container
             .tile_provider
-            .pack_tiles(&needed_indices, canvas);
+            .pack_tiles(&to_pack, canvas);
         let requires_redraw = self
             .tile_container
             .update_displayed_tiles(needed_indices, ());
@@ -137,7 +141,13 @@ impl RasterTileLayer {
             for index in iter {
                 let tile_provider = self.tile_loader.clone();
                 let messenger = self.messenger.clone();
-                Self::load_tile(index, tile_provider, self.tile_container.clone(), messenger).await;
+                Self::load_tile(
+                    index.into(),
+                    tile_provider,
+                    self.tile_container.clone(),
+                    messenger,
+                )
+                .await;
             }
         }
     }
@@ -155,7 +165,11 @@ impl Layer for RasterTileLayer {
         let displayed_tiles = self.tile_container.tiles.lock();
         let to_render: Vec<_> = displayed_tiles
             .iter()
-            .map(|v| BundleToDraw::with_opacity(&*v.bundle, v.opacity))
+            .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();
 
         canvas.draw_bundles(&to_render, RenderOptions::default());
@@ -168,7 +182,7 @@ impl Layer for RasterTileLayer {
                 let container = self.tile_container.clone();
                 let messenger = self.messenger.clone();
                 crate::async_runtime::spawn(async move {
-                    Self::load_tile(index, tile_provider, container, messenger).await;
+                    Self::load_tile(index.into(), tile_provider, container, messenger).await;
                 });
             }
         }

galileo/src/layer/raster_tile_layer/provider.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use bytes::Bytes;
+use galileo_types::cartesian::Rect;
 use maybe_sync::{MaybeSend, MaybeSync};
 use parking_lot::Mutex;
 use quick_cache::sync::Cache;
@@ -167,10 +168,12 @@ impl RasterTileProvider {
         let tiles = self.tiles.lock();
         for index in indices {
             if let Some(TileState::Loaded(image)) = tiles.get(index) {
-                let Some(tile_bbox) = self.tile_schema.tile_bbox(*index) else {
-                    log::warn!("Failed to get bbox for tile {index:?}");
+                let Some(resolution) = self.tile_schema.lod_resolution(index.z) else {
                     continue;
                 };
+                let width = self.tile_schema.tile_width() as f64;
+                let height = self.tile_schema.tile_height() as f64;
+                let tile_bbox = Rect::new(0.0, 0.0, width * resolution, -height * resolution);
 
                 let mut bundle = RenderBundle::default();
                 bundle.add_image(

galileo/src/layer/tiles.rs

@@ -4,12 +4,12 @@ use std::time::Duration;
 use parking_lot::Mutex;
 
 use crate::render::PackedBundle;
-use crate::tile_schema::TileIndex;
+use crate::tile_schema::{TileIndex, WrappingTileIndex};
 use crate::TileSchema;
 
 #[derive(Clone)]
 pub(crate) struct DisplayedTile<StyleId: Copy> {
-    pub(crate) index: TileIndex,
+    pub(crate) index: WrappingTileIndex,
     pub(crate) bundle: Arc<dyn PackedBundle>,
     style_id: StyleId,
     pub(crate) opacity: f32,
@@ -51,7 +51,7 @@ where
 
     pub(crate) fn update_displayed_tiles(
         &self,
-        needed_indices: impl IntoIterator<Item = TileIndex>,
+        needed_indices: impl IntoIterator<Item = WrappingTileIndex>,
         style_id: StyleId,
     ) -> bool {
         let mut displayed_tiles = self.tiles.lock();
@@ -78,7 +78,7 @@ where
 
                 needed_tiles.push(displayed.clone());
             } else {
-                match self.tile_provider.get_tile(index, style_id) {
+                match self.tile_provider.get_tile(index.into(), style_id) {
                     None => to_substitute.push(index),
                     Some(bundle) => {
                         needed_tiles.push(DisplayedTile {

galileo/src/layer/vector_tile_layer/mod.rs

@@ -21,7 +21,7 @@ use crate::layer::Layer;
 use crate::messenger::Messenger;
 use crate::render::render_bundle::RenderBundle;
 use crate::render::{BundleToDraw, Canvas, PackedBundle, PolygonPaint, RenderOptions};
-use crate::tile_schema::TileSchema;
+use crate::tile_schema::{TileIndex, TileSchema};
 use crate::view::MapView;
 use crate::Color;
 
@@ -87,7 +87,7 @@ impl Layer for VectorTileLayer {
     fn prepare(&self, view: &MapView) {
         if let Some(iter) = self.tile_schema.iter_tiles(view) {
             for index in iter {
-                self.tile_provider.load_tile(index, self.style_id);
+                self.tile_provider.load_tile(index.into(), self.style_id);
             }
         }
     }
@@ -145,8 +145,11 @@ impl VectorTileLayer {
         };
 
         let needed_indices: Vec<_> = tile_iter.collect();
+        let mut to_pack: Vec<TileIndex> = needed_indices.iter().map(|t| (*t).into()).collect();
+        to_pack.dedup();
+
         self.tile_provider
-            .pack_tiles(&needed_indices, self.style_id, canvas);
+            .pack_tiles(&to_pack, self.style_id, canvas);
         let requires_redraw = self
             .displayed_tiles
             .update_displayed_tiles(needed_indices, self.style_id);
@@ -207,7 +210,7 @@ impl VectorTileLayer {
 
                 let tolerance = ((view.resolution() / tile_resolution) * PIXEL_TOLERANCE) as f32;
 
-                if let Some(mvt_tile) = self.tile_provider.get_mvt_tile(index) {
+                if let Some(mvt_tile) = self.tile_provider.get_mvt_tile(index.into()) {
                     for layer in &mvt_tile.layers {
                         for feature in &layer.features {
                             match &feature.geometry {

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

@@ -1,5 +1,5 @@
 use galileo_mvt::{MvtFeature, MvtGeometry, MvtPolygon, MvtTile};
-use galileo_types::cartesian::{CartesianPoint2d, CartesianPoint3d, Point2, Point3, Vector2};
+use galileo_types::cartesian::{CartesianPoint2d, Point3, Rect, Vector2};
 use galileo_types::impls::{ClosedContour, Polygon};
 use galileo_types::{Contour, MultiContour, MultiPolygon, Polygon as PolygonTrait};
 use num_traits::ToPrimitive;
@@ -37,14 +37,15 @@ impl VtProcessor {
         style: &VectorTileStyle,
         tile_schema: &TileSchema,
     ) -> Result<(), GalileoError> {
-        let bbox = tile_schema
-            .tile_bbox(index)
-            .ok_or_else(|| GalileoError::Generic("cannot get tile bbox".into()))?;
         let lod_resolution = tile_schema.lod_resolution(index.z).ok_or_else(|| {
             GalileoError::Generic(format!("cannot get lod resolution for lod {}", index.z))
         })?;
         let tile_resolution = lod_resolution * tile_schema.tile_width() as f64;
 
+        let width = tile_schema.tile_width() as f64;
+        let height = tile_schema.tile_height() as f64;
+        let bbox = Rect::new(0.0, 0.0, width * lod_resolution, -height * lod_resolution);
+
         let bounds = Polygon::new(
             ClosedContour::new(vec![
                 Point3::new(bbox.x_min(), bbox.y_min(), 0.0),
@@ -70,13 +71,6 @@ impl VtProcessor {
 
                         for point in points {
                             let position = Self::transform_point(point, tile_resolution);
-                            if !bbox.contains(&Point2::new(position.x(), position.y())) {
-                                // Some vector tiles add out-of-bounds point to start displaying labels that
-                                // are not fully on the screen yet. We need to deal with that case
-                                // in some clever way, but for now let's ignore those points.
-                                continue;
-                            }
-
                             match &paint.shape {
                                 PointShape::Label { text, style } => {
                                     if !text.is_empty() {

galileo/src/render/mod.rs

@@ -53,15 +53,15 @@ pub trait PackedBundle: MaybeSend + MaybeSync {
     fn as_any(&self) -> &dyn Any;
 }
 
-/// Packed bundle that is ready to be renderred with the given paramters.
+/// Packed bundle that is ready to be renderred with the given parameters.
 pub struct BundleToDraw<'a> {
     bundle: &'a dyn PackedBundle,
     opacity: f32,
     pub(crate) offset: Vector2<f32>,
 }
 
 impl<'a> BundleToDraw<'a> {
-    /// Packed bundle with offset and opacity speicified.
+    /// Packed bundle with offset and opacity specified.
     pub fn new(bundle: &'a dyn PackedBundle, opacity: f32, offset: Vector2<f32>) -> Self {
         Self {
             bundle,

galileo/src/render/wgpu/mod.rs

@@ -984,8 +984,14 @@ impl Canvas for WgpuCanvas<'_> {
         let screen_sets = std::mem::take(&mut self.screen_sets);
         let mut sets: Vec<_> = screen_sets
             .iter()
-            .map(|(set, _, offset)| {
-                let locked = set.lock();
+            .filter_map(|(set, _, offset)| {
+                let Some(locked) = set.try_lock() else {
+                    // TODO: this means that the same tile is reused. We just wait for it to
+                    // disappear from the map. This would result in some visual bugs, but not so
+                    // critical as to be blocked by it ATM.
+                    return None;
+                };
+
                 let projected_anchor = transform
                     * Point4::new(
                         locked.anchor_point[0] as f64 + offset.dx() as f64,
@@ -995,7 +1001,7 @@ impl Canvas for WgpuCanvas<'_> {
                     );
                 let normalaized = projected_anchor / projected_anchor.w.abs();
 
-                (locked, normalaized, offset)
+                Some((locked, normalaized, offset))
             })
             .collect();
         sets.sort_by(|a, b| {

galileo/src/render/wgpu/pipelines/clip.rs

@@ -71,12 +71,14 @@ impl ClipPipeline {
         buffers: &'a WgpuVertexBuffers,
         render_pass: &mut RenderPass<'a>,
         render_options: RenderOptions,
+        bundle_index: u32,
     ) {
         self.render(
             buffers,
             render_pass,
             Self::CLIP_STENCIL_VALUE,
             render_options,
+            bundle_index,
         );
     }
 
@@ -85,8 +87,15 @@ impl ClipPipeline {
         buffers: &'a WgpuVertexBuffers,
         render_pass: &mut RenderPass<'a>,
         render_options: RenderOptions,
+        bundle_index: u32,
     ) {
-        self.render(buffers, render_pass, Self::UNCLIP_REFERENCE, render_options);
+        self.render(
+            buffers,
+            render_pass,
+            Self::UNCLIP_REFERENCE,
+            render_options,
+            bundle_index,
+        );
     }
 
     fn render<'a>(
@@ -95,6 +104,7 @@ impl ClipPipeline {
         render_pass: &mut RenderPass<'a>,
         stencil_reference: u32,
         render_options: RenderOptions,
+        bundle_index: u32,
     ) {
         if render_options.antialias {
             render_pass.set_pipeline(&self.wgpu_pipeline_antialias);
@@ -105,6 +115,6 @@ impl ClipPipeline {
         render_pass.set_stencil_reference(stencil_reference);
         render_pass.set_vertex_buffer(0, buffers.vertex.slice(..));
         render_pass.set_index_buffer(buffers.index.slice(..), wgpu::IndexFormat::Uint32);
-        render_pass.draw_indexed(0..buffers.index_count, 0, 0..1);
+        render_pass.draw_indexed(0..buffers.index_count, 0, bundle_index..(bundle_index + 1));
     }
 }

galileo/src/render/wgpu/pipelines/mod.rs

@@ -130,7 +130,8 @@ impl Pipelines {
         self.set_bindings(render_pass);
 
         if let Some(clip) = &bundle.clip_area_buffers {
-            self.clip.clip(clip, render_pass, render_options);
+            self.clip
+                .clip(clip, render_pass, render_options, bundle_index);
         }
 
         for image in &bundle.image_buffers {
@@ -148,7 +149,8 @@ impl Pipelines {
         }
 
         if let Some(clip) = &bundle.clip_area_buffers {
-            self.clip.unclip(clip, render_pass, render_options);
+            self.clip
+                .unclip(clip, render_pass, render_options, bundle_index);
         }
 
         if let Some(dot_buffers) = &bundle.dot_buffers {