feat: Support for line layers in MaplibreLayer

Convert maplibre line layers to Galileo vt style rules. At this point
only stroke color and width properties are supported.

Also, refactored a little how values are parsed.

Author: Maximkaaa

galileo-maplibre/src/layer/mod.rs

@@ -15,6 +15,25 @@ pub mod vector_tile;
 
 pub(crate) const UNSUPPORTED: &str = "[maplibre:unsupported]";
 
+/// Logs a debug message when an unsupported `Option`al style property is set (i.e. `Some`).
+///
+/// Usage: `log_unsupported!(layer.paint.some_field);`
+///
+/// The field path is used as the property name in the message, so no extra string is needed.
+macro_rules! log_unsupported {
+    ($field:expr) => {
+        if $field.is_some() {
+            log::debug!(
+                "{} '{}' is not supported yet; ignored",
+                $crate::layer::UNSUPPORTED,
+                stringify!($field),
+            );
+        }
+    };
+}
+
+pub(crate) use log_unsupported;
+
 /// A Galileo [`Layer`] that renders a Maplibre style definition.
 ///
 /// Internally owns one or more Galileo layers derived from the style's sources and renders them

galileo-maplibre/src/layer/vector_tile.rs

@@ -9,14 +9,14 @@ use galileo::layer::vector_tile_layer::expressions::{
     StepValue, StyleValue,
 };
 use galileo::layer::vector_tile_layer::style::{
-    StyleRule, VectorTilePolygonSymbol, VectorTileStyle, VectorTileSymbol,
+    StyleRule, VectorTileLineSymbol, VectorTilePolygonSymbol, VectorTileStyle, VectorTileSymbol,
 };
 use galileo::tile_schema::{TileSchema, TileSchemaBuilder, VerticalDirection};
 use serde::Deserialize;
 
-use crate::layer::UNSUPPORTED;
+use crate::layer::{UNSUPPORTED, log_unsupported};
 use crate::style::color::MlColor;
-use crate::style::layer::{FillLayer, Layer as MaplibreStyleLayer};
+use crate::style::layer::{FillLayer, Layer as MaplibreStyleLayer, LineLayer};
 use crate::style::source::{TileScheme, VectorSource};
 use crate::style::value::{FunctionStop, MlStyleValue};
 
@@ -92,22 +92,19 @@ fn get_background(layers: &[&MaplibreStyleLayer]) -> StyleValue<Color> {
         }
     };
 
-    let Some(color) = &layer.paint.background_color else {
-        return DEFAULT_TILE_BACKGROUND;
-    };
-
-    get_color_value(color, layer.paint.background_opacity.as_ref())
-        .unwrap_or(DEFAULT_TILE_BACKGROUND)
+    get_color_value(
+        &layer.paint.background_color,
+        &layer.paint.background_opacity,
+    )
+    .unwrap_or(DEFAULT_TILE_BACKGROUND)
 }
 
 fn get_color_value(
     color: &MlStyleValue<MlColor>,
-    opacity: Option<&MlStyleValue<f64>>,
+    opacity: &MlStyleValue<f64>,
 ) -> Option<StyleValue<Color>> {
     let galileo_color = get_galileo_value(color)?;
-    let galileo_opacity = opacity
-        .and_then(get_galileo_value)
-        .unwrap_or(StyleValue::Simple(1.0));
+    let galileo_opacity = get_galileo_value(opacity).unwrap_or(StyleValue::Simple(1.0));
 
     match (galileo_color, galileo_opacity) {
         (StyleValue::Simple(c), StyleValue::Simple(o)) => Some((*c).with_alpha_float(o).into()),
@@ -194,11 +191,11 @@ fn build_rules(layers: &[&MaplibreStyleLayer], tile_schema: &TileSchema) -> Vec<
             MaplibreStyleLayer::Fill(fill) => {
                 if let Some(rule) = fill_rule(fill, tile_schema) {
                     rules.push(rule);
-                    log::debug!(
-                        "Maplibre layer '{}' of type '{}' is added as a VT style rule",
-                        layer.id(),
-                        layer.type_name()
-                    );
+                }
+            }
+            MaplibreStyleLayer::Line(line) => {
+                if let Some(rule) = line_rule(line, tile_schema) {
+                    rules.push(rule);
                 }
             }
             other => {
@@ -208,8 +205,16 @@ fn build_rules(layers: &[&MaplibreStyleLayer], tile_schema: &TileSchema) -> Vec<
                     other.type_name(),
                     other.id(),
                 );
+
+                continue;
             }
         }
+
+        log::trace!(
+            "Maplibre layer '{}' of type '{}' is added as a VT style rule",
+            layer.id(),
+            layer.type_name()
+        );
     }
     rules
 }
@@ -227,9 +232,16 @@ fn fill_rule(fill: &FillLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
         }
     };
 
-    let fill_color = fill.paint.fill_color.as_ref()?;
+    let fill_color = &fill.paint.fill_color;
     let fill_opacity = &fill.paint.fill_opacity;
-    let color = get_color_value(fill_color, fill_opacity.as_ref())?;
+    let color = get_color_value(fill_color, fill_opacity)?;
+
+    log_unsupported!(fill.paint.fill_antialias);
+    log_unsupported!(fill.paint.fill_outline_color);
+    log_unsupported!(fill.paint.fill_pattern);
+    log_unsupported!(fill.paint.fill_translate);
+    log_unsupported!(fill.paint.fill_translate_anchor);
+    log_unsupported!(fill.paint.fill_emissive_strength);
 
     let min_resolution = fill
         .maxzoom
@@ -247,6 +259,61 @@ fn fill_rule(fill: &FillLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
     })
 }
 
+/// Converts a [`LineLayer`] to a [`StyleRule`], or logs and returns `None` if unsupported.
+fn line_rule(line: &LineLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
+    if line.paint.line_dasharray.is_some() {
+        log::debug!(
+            "{UNSUPPORTED} Line dasharray is not supported yet; skipping layer {}",
+            line.id
+        );
+        return None;
+    }
+
+    log_unsupported!(line.paint.line_blur);
+    log_unsupported!(line.paint.line_gap_width);
+    log_unsupported!(line.paint.line_gradient);
+    log_unsupported!(line.paint.line_pattern);
+    log_unsupported!(line.paint.line_translate);
+    log_unsupported!(line.paint.line_translate_anchor);
+    log_unsupported!(line.paint.line_emissive_strength);
+    log_unsupported!(line.paint.line_offset);
+
+    let source_layer = match &line.source_layer {
+        Some(l) => l.clone(),
+        None => {
+            log::debug!(
+                "{UNSUPPORTED} Line layer '{}' has no source-layer; skipping.",
+                line.id
+            );
+            return None;
+        }
+    };
+
+    let stroke_color = &line.paint.line_color;
+    let stroke_opacity = &line.paint.line_opacity;
+    let color = get_color_value(stroke_color, stroke_opacity).unwrap_or(Color::TRANSPARENT.into());
+    let stroke_width = &line.paint.line_width;
+    let width = get_galileo_value(stroke_width).unwrap_or(1.0.into());
+
+    let min_resolution = line
+        .maxzoom
+        .and_then(|lod| tile_schema.lod_resolution(lod.round() as u32));
+    let max_resolution = line
+        .minzoom
+        .and_then(|lod| tile_schema.lod_resolution(lod.round() as u32));
+
+    Some(StyleRule {
+        layer_name: Some(source_layer),
+        symbol: VectorTileSymbol::Line(VectorTileLineSymbol {
+            width,
+            stroke_color: color,
+        }),
+        min_resolution,
+        max_resolution,
+        ..Default::default()
+    })
+}
+
 /// Converts WGS84 bounding box `[west, south, east, north]` (degrees) to a Web Mercator [`Rect`]
 /// in projected meters, suitable for use with [`TileSchemaBuilder::tile_bounds`].
 fn wgs84_bounds_to_mercator(bounds: [f64; 4]) -> Option<Rect> {

galileo-maplibre/src/style/color.rs

@@ -6,7 +6,7 @@ use galileo::Color;
 use serde::{Deserialize, Deserializer};
 
 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
-pub struct MlColor(Color);
+pub struct MlColor(pub(crate) Color);
 
 impl<'de> Deserialize<'de> for MlColor {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

galileo-maplibre/src/style/layer/background.rs

@@ -5,18 +5,31 @@ use serde_json::Value;
 
 use super::common::CommonLayout;
 use crate::style::color::MlColor;
-use crate::style::deserialize_opt_f64;
 use crate::style::value::MlStyleValue;
+use crate::style::{
+    default_one, default_transparent, deser_default_one, deser_default_transparent,
+    deserialize_opt_f64,
+};
 
 /// Paint properties for a background layer.
-#[derive(Debug, Clone, PartialEq, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct BackgroundPaint {
     /// The colour with which the background will be drawn.
-    #[serde(rename = "background-color")]
-    pub background_color: Option<MlStyleValue<MlColor>>,
+    #[serde(
+        rename = "background-color",
+        default = "default_transparent",
+        deserialize_with = "deser_default_transparent"
+    )]
+    pub background_color: MlStyleValue<MlColor>,
+
     /// The opacity at which the background will be drawn.
-    #[serde(rename = "background-opacity")]
-    pub background_opacity: Option<MlStyleValue<f64>>,
+    #[serde(
+        rename = "background-opacity",
+        default = "default_one",
+        deserialize_with = "deser_default_one"
+    )]
+    pub background_opacity: MlStyleValue<f64>,
+
     /// Name of image in sprite to use for drawing an image background.
     #[serde(rename = "background-pattern")]
     pub background_pattern: Option<Value>,
@@ -25,6 +38,17 @@ pub struct BackgroundPaint {
     pub background_emissive_strength: Option<Value>,
 }
 
+impl Default for BackgroundPaint {
+    fn default() -> Self {
+        Self {
+            background_color: default_transparent(),
+            background_opacity: default_one(),
+            background_pattern: Default::default(),
+            background_emissive_strength: Default::default(),
+        }
+    }
+}
+
 /// Layout properties for a background layer (visibility only).
 pub type BackgroundLayout = CommonLayout;
 

galileo-maplibre/src/style/layer/fill.rs

@@ -5,11 +5,14 @@ use serde_json::Value;
 
 use super::common::CommonLayout;
 use crate::style::color::MlColor;
-use crate::style::deserialize_opt_f64;
 use crate::style::value::MlStyleValue;
+use crate::style::{
+    default_one, default_transparent, deser_default_one, deser_default_transparent,
+    deserialize_opt_f64,
+};
 
 /// Paint properties for a `fill` layer.
-#[derive(Debug, Clone, PartialEq, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct FillPaint {
     /// Whether or not the fill should be antialiased. Supports expressions.
     #[serde(rename = "fill-antialias", skip_serializing_if = "Option::is_none")]
@@ -18,22 +21,24 @@ pub struct FillPaint {
     /// Fill colour.
     #[serde(
         rename = "fill-color",
-        default,
+        default = "default_transparent",
+        deserialize_with = "deser_default_transparent",
         skip_serializing_if = "Option::is_none"
     )]
-    pub fill_color: Option<MlStyleValue<MlColor>>,
+    pub fill_color: MlStyleValue<MlColor>,
 
     /// Outline colour.
+    #[serde(rename = "fill-outline-color", skip_serializing_if = "Option::is_none")]
+    pub fill_outline_color: Option<Value>,
+
+    /// Opacity of the entire fill layer. Supports expressions.
     #[serde(
-        rename = "fill-outline-color",
-        default,
+        rename = "fill-opacity",
+        default = "default_one",
+        deserialize_with = "deser_default_one",
         skip_serializing_if = "Option::is_none"
     )]
-    pub fill_outline_color: Option<MlStyleValue<MlColor>>,
-
-    /// Opacity of the entire fill layer. Supports expressions.
-    #[serde(rename = "fill-opacity", skip_serializing_if = "Option::is_none")]
-    pub fill_opacity: Option<MlStyleValue<f64>>,
+    pub fill_opacity: MlStyleValue<f64>,
 
     /// Name of image in sprite to use for drawing the fill pattern.
     #[serde(rename = "fill-pattern", skip_serializing_if = "Option::is_none")]
@@ -58,6 +63,21 @@ pub struct FillPaint {
     pub fill_emissive_strength: Option<Value>,
 }
 
+impl Default for FillPaint {
+    fn default() -> Self {
+        Self {
+            fill_antialias: Default::default(),
+            fill_color: default_transparent(),
+            fill_outline_color: Default::default(),
+            fill_opacity: default_one(),
+            fill_pattern: Default::default(),
+            fill_translate: Default::default(),
+            fill_translate_anchor: Default::default(),
+            fill_emissive_strength: Default::default(),
+        }
+    }
+}
+
 /// Layout properties for a `fill` layer (visibility only).
 pub type FillLayout = CommonLayout;