feat: support HiDPI scaling in galileo-egui (galileo-map#220)

---------

Co-authored-by: Alex Boehm <[email protected]>
Co-authored-by: Maxim <[email protected]>

Author: 3 people

galileo-egui/src/egui_map.rs

@@ -146,6 +146,7 @@ pub struct EguiMapState {
     texture_view: TextureView,
     event_processor: EventProcessor,
     messenger: MapStateMessenger,
+    map_ready: bool,
 }
 
 impl<'a> EguiMapState {
@@ -177,6 +178,7 @@ impl<'a> EguiMapState {
         // This size will be replaced by the UI on the first frame.
         let size = Size::new(1, 1);
         map.set_size(size.cast());
+        map.set_view(map.view().with_dpi_scale_factor(ctx.pixels_per_point()));
 
         let mut renderer = WgpuRenderer::new_with_device_and_texture(
             render_state.device.clone(),
@@ -209,6 +211,7 @@ impl<'a> EguiMapState {
             texture_view: texture,
             event_processor,
             messenger,
+            map_ready: false,
         }
     }
 
@@ -219,10 +222,13 @@ impl<'a> EguiMapState {
 
     /// Renders the map into UI.
     pub fn render(&mut self, ui: &mut egui::Ui) {
-        let available_size = ui.available_size().floor();
-        let map_size = self.renderer.size().cast::<f32>();
+        let logical_size = ui.available_size().floor();
+        let pixels_per_point = ui.ctx().pixels_per_point();
+        let physical_size = logical_size * pixels_per_point;
 
-        let (rect, response) = ui.allocate_exact_size(available_size, Sense::click_and_drag());
+        let (rect, response) = ui.allocate_exact_size(logical_size, Sense::click_and_drag());
+
+        let renderer_size = self.renderer.size().cast::<f32>();
 
         let attributions = self.collect_attributions();
         if attributions.is_some() {
@@ -243,8 +249,15 @@ impl<'a> EguiMapState {
 
         self.map.animate();
 
-        if available_size[0] != map_size.width() || available_size[1] != map_size.height() {
-            self.resize_map(available_size);
+        if physical_size[0] != renderer_size.width() || physical_size[1] != renderer_size.height() {
+            self.map_ready = true;
+            self.resize_map(logical_size, pixels_per_point);
+            self.map
+                .set_view(self.map.view().with_dpi_scale_factor(pixels_per_point));
+        }
+
+        if self.map_ready {
+            self.map.load_layers();
         }
 
         if self.requires_redraw.swap(false, Ordering::Relaxed) {
@@ -253,7 +266,7 @@ impl<'a> EguiMapState {
 
         Image::new(ImageSource::Texture(SizedTexture::new(
             self.texture_id,
-            Vec2::new(map_size.width(), map_size.height()),
+            Vec2::new(renderer_size.width(), renderer_size.height()),
         )))
         .paint_at(ui, rect);
     }
@@ -309,30 +322,42 @@ impl<'a> EguiMapState {
         self.messenger.clone()
     }
 
-    fn resize_map(&mut self, size: Vec2) {
-        log::trace!("Resizing map to size: {size:?}");
+    fn resize_map(&mut self, logical_size: Vec2, pixels_per_point: f32) {
+        log::trace!(
+            "Resizing map to logical size: {logical_size:?}, pixels_per_point: {pixels_per_point}"
+        );
 
-        let size = Size::new(size.x as f64, size.y as f64);
-        self.map.set_size(size);
+        // Set the logical size for the map
+        let logical_size_f64 = Size::new(logical_size.x as f64, logical_size.y as f64);
+        self.map.set_size(logical_size_f64);
 
-        let size = Size::new(size.width() as u32, size.height() as u32);
-        self.renderer.resize(size);
+        // Resize the renderer to physical size (accounting for pixel density)
+        let physical_size = Size::new(
+            (logical_size.x * pixels_per_point) as u32,
+            (logical_size.y * pixels_per_point) as u32,
+        );
+        self.renderer.resize(physical_size);
 
         // After renderer is resized, a new texture is created, so we need to update its id that we
         // use in UI.
         let texture = self
             .renderer
             .get_target_texture_view()
             .expect("failed to get map texture");
+
+        // Use Linear filtering for better quality on HiDPI displays
+        let filter_mode = if pixels_per_point > 1.0 {
+            FilterMode::Linear
+        } else {
+            FilterMode::Nearest
+        };
+        log::info!("Using filter mode: {filter_mode:?}");
+
         let texture_id = self
             .egui_render_state
             .renderer
             .write()
-            .register_native_texture(
-                &self.egui_render_state.device,
-                &texture,
-                FilterMode::Nearest,
-            );
+            .register_native_texture(&self.egui_render_state.device, &texture, filter_mode);
 
         self.texture_id = texture_id;
         self.texture_view = texture;

galileo-mvt/src/lib.rs

@@ -285,7 +285,7 @@ impl MvtFeature {
         values: &[MvtValue],
     ) -> Result<HashMap<String, MvtValue>, GalileoMvtError> {
         let mut properties = HashMap::new();
-        if tags.len() % 2 != 0 {
+        if !tags.len().is_multiple_of(2) {
             return Err(GalileoMvtError::Generic(
                 "Invalid number of tags in feature".into(),
             ));

galileo/src/layer/feature_layer/bundle_store.rs

@@ -91,9 +91,13 @@ impl BundleStore {
         self.required_update.update_all();
     }
 
-    pub(super) fn with_bundle(&mut self, predicate: impl FnOnce(&mut RenderBundle) -> FeatureId) {
+    pub(super) fn with_bundle(
+        &mut self,
+        predicate: impl FnOnce(&mut RenderBundle) -> FeatureId,
+        dpi_scale_factor: f32,
+    ) {
         let (bundle_id, curr_bundle) = {
-            let v = self.curr_bundle();
+            let v = self.curr_bundle(dpi_scale_factor);
             (v.0, &mut v.1)
         };
 
@@ -104,10 +108,11 @@ impl BundleStore {
         self.feature_to_bundle_map.insert(feature_id, bundle_id);
     }
 
-    fn curr_bundle(&mut self) -> &mut (BundleId, RenderBundle) {
+    fn curr_bundle(&mut self, dpi_scale_factor: f32) -> &mut (BundleId, RenderBundle) {
         if self.last_bundle_is_full() {
             let new_id = BundleId::next();
-            self.unpacked.push((new_id, RenderBundle::default()));
+            self.unpacked
+                .push((new_id, RenderBundle::new(dpi_scale_factor)));
         }
 
         let idx = self.unpacked.len() - 1;

galileo/src/layer/feature_layer/mod.rs

@@ -232,33 +232,40 @@ where
     ) {
         let lod = self.select_lod(view.resolution());
         let mut store = lod.bundles.lock();
+        let dpi_scale_factor = view.dpi_scale_factor();
 
         match store.required_update() {
             UpdateType::All => {
                 for (id, feature) in self.features.iter() {
-                    store.with_bundle(|bundle| {
-                        if let Some(projected) = feature.geometry().project(&*projection) {
-                            self.symbol
-                                .render(feature, &projected, lod.min_resolution, bundle);
-                        }
-
-                        id
-                    });
+                    store.with_bundle(
+                        |bundle| {
+                            if let Some(projected) = feature.geometry().project(&*projection) {
+                                self.symbol
+                                    .render(feature, &projected, lod.min_resolution, bundle);
+                            }
+
+                            id
+                        },
+                        dpi_scale_factor,
+                    );
                 }
             }
             UpdateType::Selected(ids) => {
                 for id in ids {
                     let Some(feature) = self.features.get(id) else {
                         continue;
                     };
-                    store.with_bundle(|bundle| {
-                        if let Some(projected) = feature.geometry().project(&*projection) {
-                            self.symbol
-                                .render(feature, &projected, lod.min_resolution, bundle);
-                        }
-
-                        id
-                    });
+                    store.with_bundle(
+                        |bundle| {
+                            if let Some(projected) = feature.geometry().project(&*projection) {
+                                self.symbol
+                                    .render(feature, &projected, lod.min_resolution, bundle);
+                            }
+
+                            id
+                        },
+                        dpi_scale_factor,
+                    );
                 }
             }
             UpdateType::None => {}

galileo/src/layer/vector_tile_layer/mod.rs

@@ -239,7 +239,7 @@ impl VectorTileLayer {
         view: &MapView,
         canvas: &mut dyn Canvas,
     ) -> Option<Box<dyn PackedBundle>> {
-        let mut bundle = RenderBundle::default();
+        let mut bundle = RenderBundle::new(view.dpi_scale_factor());
         let bbox = view.get_bbox()?;
         let bounds = Polygon::new(
             ClosedContour::new(vec![

galileo/src/map/mod.rs

@@ -75,7 +75,6 @@ impl Map {
             layer.prepare(&self.view);
         }
     }
-
     /// Request redraw of the map.
     pub fn redraw(&self) {
         if let Some(messenger) = &self.messenger {

galileo/src/render/render_bundle/mod.rs

@@ -27,6 +27,14 @@ pub struct RenderBundle {
 }
 
 impl RenderBundle {
+    /// Creates a new render bundle with the given DPI scale factor.
+    pub fn new(dpi_scale_factor: f32) -> Self {
+        Self {
+            world_set: WorldRenderSet::new(dpi_scale_factor),
+            screen_sets: Vec::new(),
+        }
+    }
+
     /// Adds an image to the bundle.
     pub fn add_image(
         &mut self,

galileo/src/render/render_bundle/screen_set.rs

@@ -67,7 +67,7 @@ impl ScreenRenderSet {
         N: AsPrimitive<f32>,
         P: CartesianPoint3d<Num = N>,
     {
-        match TextService::shape(text, style, offset) {
+        match TextService::shape(text, style, offset, 1.0) {
             Ok(TextShaping::Tessellation { glyphs, .. }) => {
                 let mut vertices = vec![];
                 let mut indices = vec![];

galileo/src/render/render_bundle/world_set.rs

@@ -31,6 +31,7 @@ pub(crate) struct WorldRenderSet {
     pub clip_area: Option<VertexBuffers<PolyVertex, u32>>,
     pub image_store: Vec<Arc<DecodedImage>>,
     pub buffer_size: usize,
+    dpi_scale_factor: f32,
 }
 
 #[repr(C)]
@@ -50,19 +51,20 @@ pub(crate) struct ScreenRefVertex {
 
 impl Default for WorldRenderSet {
     fn default() -> Self {
-        Self::new()
+        Self::new(1.0)
     }
 }
 
 impl WorldRenderSet {
-    pub fn new() -> Self {
+    pub fn new(dpi_scale_factor: f32) -> Self {
         Self {
             poly_tessellation: VertexBuffers::new(),
             points: Vec::new(),
             images: Vec::new(),
             clip_area: None,
             image_store: Vec::new(),
             buffer_size: 0,
+            dpi_scale_factor,
         }
     }
 
@@ -246,7 +248,7 @@ impl WorldRenderSet {
         let path = path_builder.build();
 
         let vertex_constructor = LineVertexConstructor {
-            width: paint.width as f32,
+            width: paint.width as f32 * self.dpi_scale_factor,
             offset: paint.offset as f32,
             color: paint.color.to_f32_array(),
             resolution: min_resolution as f32,
@@ -374,7 +376,7 @@ impl WorldRenderSet {
         P: CartesianPoint3d<Num = N>,
     {
         let mut path_builder = BuilderWithAttributes::new(0);
-        build_contour_path(&mut path_builder, shape, scale);
+        build_contour_path(&mut path_builder, shape, scale * self.dpi_scale_factor);
         let path = path_builder.build();
 
         let start_vertex_count = self.poly_tessellation.vertices.len();
@@ -475,7 +477,7 @@ impl WorldRenderSet {
 
         let is_full_circle = (dr - std::f32::consts::PI * 2.0).abs() < TOLERANCE;
 
-        let mut contour = get_circle_sector(radius, start_angle, end_angle);
+        let mut contour = get_circle_sector(radius * self.dpi_scale_factor, start_angle, end_angle);
         let first_index = self.poly_tessellation.vertices.len() as u32;
 
         let start_vertex_count = self.poly_tessellation.vertices.len();
@@ -507,15 +509,16 @@ impl WorldRenderSet {
         self.poly_tessellation.vertices.append(&mut vertices);
         self.poly_tessellation.indices.append(&mut indices);
 
-        if outline.is_some() {
+        if let Some(mut outline) = outline {
             if !is_full_circle {
                 contour.push(Point2::new(0.0, 0.0));
             }
+            outline.width *= self.dpi_scale_factor as f64;
             self.add_shape(
                 position,
                 Color::TRANSPARENT,
                 radius,
-                outline,
+                Some(outline),
                 &ClosedContour::new(contour),
                 offset,
             );
@@ -554,7 +557,7 @@ impl WorldRenderSet {
         N: AsPrimitive<f32>,
         P: CartesianPoint3d<Num = N>,
     {
-        match TextService::shape(text, style, offset) {
+        match TextService::shape(text, style, offset, self.dpi_scale_factor) {
             Ok(TextShaping::Tessellation { glyphs, .. }) => {
                 for glyph in glyphs {
                     let vertices_start = self.poly_tessellation.vertices.len() as u32;

galileo/src/render/text/mod.rs

@@ -119,6 +119,7 @@ pub trait TextRasterizer {
         style: &TextStyle,
         offset: Vector2<f32>,
         font_provider: &dyn FontProvider,
+        dpi_scale_factor: f32,
     ) -> Result<TextShaping, FontServiceError>;
 }