feat: Convert Maplibre symbol layers to Galileo labels

Maximkaaa · Maximkaaa · commit 615daf230b42 · 2026-04-23T00:10:16.000+09:00
This commit adds basic logic for converting Maplibre labels to Galileo
ones.
diff --git a/galileo-maplibre/examples/maplibre_style.rs b/galileo-maplibre/examples/maplibre_style.rs
@@ -1,4 +1,6 @@
 use galileo::MapBuilder;
+use galileo::render::text::RustybuzzRasterizer;
+use galileo::render::text::text_service::TextService;
 use galileo_maplibre::MaplibreLayer;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -20,6 +22,8 @@ fn main() {
 }
 
 async fn create_map(style_path: &str) -> galileo::Map {
+    initialize_font_service();
+
     let Some(api_key) = std::option_env!("VT_API_KEY") else {
         panic!(
             "Set the MapTiler API key into VT_API_KEY environment variable when building this example"
@@ -38,3 +42,8 @@ async fn create_map(style_path: &str) -> galileo::Map {
         .with_layer(layer)
         .build()
 }
+
+fn initialize_font_service() {
+    let rasterizer = RustybuzzRasterizer::default();
+    TextService::initialize(rasterizer).load_fonts("galileo/examples/data/fonts");
+}
diff --git a/galileo-maplibre/src/layer/vector_tile.rs b/galileo-maplibre/src/layer/vector_tile.rs
@@ -8,14 +8,16 @@ use galileo::galileo_types::geo::{Crs, NewGeoPoint, Projection};
 use galileo::layer::VectorTileLayer;
 use galileo::layer::vector_tile_layer::VectorTileLayerBuilder;
 use galileo::layer::vector_tile_layer::style::{
-    StyleRule, VectorTileLineSymbol, VectorTilePolygonSymbol, VectorTileStyle, VectorTileSymbol,
+    StyleRule, VectorTileLabelSymbol, VectorTileLineSymbol, VectorTilePolygonSymbol,
+    VectorTileStyle, VectorTileSymbol, VtTextStyle,
 };
+use galileo::render::text::{FontStyle, FontWeight, HorizontalAlignment, VerticalAlignment};
 use galileo::tile_schema::{TileSchema, TileSchemaBuilder, VerticalDirection};
 use serde::Deserialize;
 
 use crate::layer::{UNSUPPORTED, log_unsupported_field};
 use crate::style::color::MlColor;
-use crate::style::layer::{FillLayer, Layer as MaplibreStyleLayer, LineLayer};
+use crate::style::layer::{FillLayer, Layer as MaplibreStyleLayer, LineLayer, SymbolLayer};
 use crate::style::source::{TileScheme, VectorSource};
 use crate::style::value::{FunctionStop, FunctionType, MlStyleValue};
 
@@ -197,6 +199,11 @@ fn build_rules(layers: &[&MaplibreStyleLayer], tile_schema: &TileSchema) -> Vec<
                     rules.push(rule);
                 }
             }
+            MaplibreStyleLayer::Symbol(symbol) => {
+                if let Some(rule) = symbol_rule(symbol, tile_schema) {
+                    rules.push(rule);
+                }
+            }
             other => {
                 log::debug!(
                     "{UNSUPPORTED} Maplibre layer type '{}' (id: '{}') inside a vector source \
@@ -218,6 +225,151 @@ fn build_rules(layers: &[&MaplibreStyleLayer], tile_schema: &TileSchema) -> Vec<
     rules
 }
 
+fn symbol_rule(symbol: &SymbolLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
+    let source_layer = match &symbol.source_layer {
+        Some(l) => l.clone(),
+        None => {
+            log::debug!(
+                "{UNSUPPORTED} Symbol layer '{}' has no source-layer; skipping.",
+                symbol.id
+            );
+            return None;
+        }
+    };
+
+    let min_resolution = symbol
+        .maxzoom
+        .and_then(|lod| tile_schema.lod_resolution(lod.round() as u32));
+    let max_resolution = symbol
+        .minzoom
+        .and_then(|lod| tile_schema.lod_resolution(lod.round() as u32));
+    let filter = symbol.filter.as_ref().and_then(|v| v.to_galileo_expr());
+
+    let font_color = get_color_value(&symbol.paint.text_color, &symbol.paint.text_opacity)?;
+    let outline_color =
+        get_color_value(&symbol.paint.text_halo_color, &MlStyleValue::Literal(1.0))?;
+    let font_size = get_galileo_value(
+        &symbol
+            .layout
+            .text_size
+            .clone()
+            .unwrap_or_else(|| 16.0.into()),
+    )?;
+    let outline_width = get_galileo_value(
+        &symbol
+            .paint
+            .text_halo_width
+            .clone()
+            .unwrap_or_else(|| 0.0.into()),
+    )?;
+
+    let (font_family, weight, font_style) = parse_ml_fonts(&symbol.layout.text_font);
+
+    let style = VtTextStyle {
+        font_family,
+        font_size: font_size.into(),
+        font_color: font_color.into(),
+        horizontal_alignment: match symbol.layout.text_anchor.as_deref() {
+            Some("left") | Some("top-left") | Some("bottom-left") => HorizontalAlignment::Left,
+            Some("right") | Some("top-right") | Some("bottom-right") => HorizontalAlignment::Right,
+            _ => HorizontalAlignment::Center,
+        },
+        vertical_alignment: match symbol.layout.text_anchor.as_deref() {
+            Some("top") | Some("top-left") | Some("top-right") => VerticalAlignment::Top,
+            Some("bottom") | Some("bottom-left") | Some("bottom-right") => {
+                VerticalAlignment::Bottom
+            }
+            _ => VerticalAlignment::Middle,
+        },
+        weight,
+        style: font_style,
+        outline_width: outline_width.into(),
+        outline_color: outline_color.into(),
+    };
+
+    Some(StyleRule {
+        layer_name: Some(source_layer),
+        symbol: VectorTileSymbol::Label(VectorTileLabelSymbol {
+            pattern: symbol.layout.text_field.clone().unwrap_or_default(),
+            text_style: style,
+        }),
+        min_resolution,
+        max_resolution,
+        filter: filter.map(Into::into),
+    })
+}
+
+/// Parses Maplibre `text-font` entries into a font family list, [`FontWeight`], and [`FontStyle`].
+///
+/// Maplibre encodes weight and style as suffixes appended to the family name, e.g.
+/// `"Roboto Bold Italic"` or `"Noto Sans Regular"`. This function strips the known
+/// weight and style keywords from the end of each entry to recover the bare family name, and
+/// derives `FontWeight` / `FontStyle` from the first entry that contains them.
+///
+/// All family names are collected so the renderer can fall back through the list.
+fn parse_ml_fonts(text_font: &[String]) -> (Vec<String>, FontWeight, FontStyle) {
+    const STYLES: &[(&str, FontStyle)] = &[
+        ("Italic", FontStyle::Italic),
+        ("Oblique", FontStyle::Oblique),
+    ];
+
+    const WEIGHTS: &[(&str, FontWeight)] = &[
+        ("Thin", FontWeight::THIN),
+        ("ExtraLight", FontWeight::EXTRA_LIGHT),
+        ("Light", FontWeight::LIGHT),
+        ("Regular", FontWeight::NORMAL),
+        ("Medium", FontWeight::MEDIUM),
+        ("SemiBold", FontWeight::SEMI_BOLD),
+        ("Bold", FontWeight::BOLD),
+        ("ExtraBold", FontWeight::EXTRA_BOLD),
+        ("Black", FontWeight::BLACK),
+        ("Heavy", FontWeight::BLACK),
+    ];
+
+    let mut families = Vec::with_capacity(text_font.len());
+    let mut resolved_weight = FontWeight::NORMAL;
+    let mut resolved_style = FontStyle::Normal;
+    let mut style_resolved = false;
+
+    for font_str in text_font {
+        let mut rest = font_str.trim();
+
+        if !style_resolved {
+            if let Some((suffix, s)) = STYLES.iter().find(|(kw, _)| rest.ends_with(*kw)) {
+                rest = rest[..rest.len() - suffix.len()].trim();
+                resolved_style = *s;
+            }
+
+            if let Some((suffix, w)) = WEIGHTS.iter().find(|(kw, _)| rest.ends_with(*kw)) {
+                rest = rest[..rest.len() - suffix.len()].trim();
+                resolved_weight = *w;
+            }
+
+            style_resolved = true;
+        } else {
+            // For fallback fonts, strip any trailing style/weight keywords too.
+            for (suffix, _) in STYLES.iter() {
+                if rest.ends_with(*suffix) {
+                    rest = rest[..rest.len() - suffix.len()].trim();
+                    break;
+                }
+            }
+            for (suffix, _) in WEIGHTS.iter() {
+                if rest.ends_with(*suffix) {
+                    rest = rest[..rest.len() - suffix.len()].trim();
+                    break;
+                }
+            }
+        }
+
+        if !rest.is_empty() {
+            families.push(rest.to_string());
+        }
+    }
+
+    (families, resolved_weight, resolved_style)
+}
+
 /// Converts a [`FillLayer`] to a [`StyleRule`], or logs and returns `None` if unsupported.
 fn fill_rule(fill: &FillLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
     let source_layer = match &fill.source_layer {
diff --git a/galileo-maplibre/src/style/layer/mod.rs b/galileo-maplibre/src/style/layer/mod.rs
@@ -217,7 +217,7 @@ mod tests {
         };
         assert_eq!(s.id, "Labels");
         assert!(s.layout.text_field.is_some());
-        assert!(s.layout.text_font.is_some());
+        assert_eq!(&s.layout.text_font, &["Open Sans Regular".to_string()]);
     }
 
     #[test]
diff --git a/galileo-maplibre/src/style/layer/symbol.rs b/galileo-maplibre/src/style/layer/symbol.rs
@@ -4,10 +4,23 @@ use serde::Deserialize;
 use serde_json::Value;
 
 use super::common::{Visibility, deserialize_visibility_or_default};
-use crate::style::deserialize_opt_f64;
+use crate::style::color::MlColor;
+use crate::style::expression::MlExpr;
+use crate::style::value::MlStyleValue;
+use crate::style::{
+    default_one, default_transparent, deser_default_one, deser_default_transparent,
+    deserialize_opt_f64,
+};
+
+fn default_font() -> Vec<String> {
+    vec![
+        "Open Sans Regular".to_string(),
+        "Arial Unicode MS Regular".to_string(),
+    ]
+}
 
 /// Paint properties for a `symbol` layer.
-#[derive(Debug, Clone, PartialEq, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct SymbolPaint {
     /// Icon colour. Supports expressions.
     #[serde(rename = "icon-color", skip_serializing_if = "Option::is_none")]
@@ -26,8 +39,13 @@ pub struct SymbolPaint {
     pub icon_halo_blur: Option<Value>,
 
     /// Icon opacity. Supports expressions.
-    #[serde(rename = "icon-opacity", skip_serializing_if = "Option::is_none")]
-    pub icon_opacity: Option<Value>,
+    #[serde(
+        rename = "icon-opacity",
+        default = "default_one",
+        deserialize_with = "deser_default_one",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub icon_opacity: MlStyleValue<f64>,
 
     /// Icon translation offset. Supports expressions.
     #[serde(rename = "icon-translate", skip_serializing_if = "Option::is_none")]
@@ -48,24 +66,37 @@ pub struct SymbolPaint {
     pub icon_emissive_strength: Option<Value>,
 
     /// Text colour. Supports expressions.
-    #[serde(rename = "text-color", skip_serializing_if = "Option::is_none")]
-    pub text_color: Option<Value>,
+    #[serde(
+        rename = "text-color",
+        default = "default_transparent",
+        deserialize_with = "deser_default_transparent"
+    )]
+    pub text_color: MlStyleValue<MlColor>,
 
     /// Text halo colour. Supports expressions.
-    #[serde(rename = "text-halo-color", skip_serializing_if = "Option::is_none")]
-    pub text_halo_color: Option<Value>,
+    #[serde(
+        rename = "text-halo-color",
+        default = "default_transparent",
+        deserialize_with = "deser_default_transparent"
+    )]
+    pub text_halo_color: MlStyleValue<MlColor>,
 
     /// Width of the halo around text. Supports expressions.
     #[serde(rename = "text-halo-width", skip_serializing_if = "Option::is_none")]
-    pub text_halo_width: Option<Value>,
+    pub text_halo_width: Option<MlStyleValue<f64>>,
 
     /// Fade out the halo towards the outside. Supports expressions.
     #[serde(rename = "text-halo-blur", skip_serializing_if = "Option::is_none")]
     pub text_halo_blur: Option<Value>,
 
     /// Text opacity. Supports expressions.
-    #[serde(rename = "text-opacity", skip_serializing_if = "Option::is_none")]
-    pub text_opacity: Option<Value>,
+    #[serde(
+        rename = "text-opacity",
+        default = "default_one",
+        deserialize_with = "deser_default_one",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub text_opacity: MlStyleValue<f64>,
 
     /// Text translation offset. Supports expressions.
     #[serde(rename = "text-translate", skip_serializing_if = "Option::is_none")]
@@ -86,6 +117,29 @@ pub struct SymbolPaint {
     pub text_emissive_strength: Option<Value>,
 }
 
+impl Default for SymbolPaint {
+    fn default() -> Self {
+        Self {
+            icon_color: Default::default(),
+            icon_halo_color: Default::default(),
+            icon_halo_width: Default::default(),
+            icon_halo_blur: Default::default(),
+            icon_opacity: default_one(),
+            icon_translate: Default::default(),
+            icon_translate_anchor: Default::default(),
+            icon_emissive_strength: Default::default(),
+            text_color: default_transparent(),
+            text_halo_color: default_transparent(),
+            text_halo_width: Default::default(),
+            text_halo_blur: Default::default(),
+            text_opacity: default_one(),
+            text_translate: Default::default(),
+            text_translate_anchor: Default::default(),
+            text_emissive_strength: Default::default(),
+        }
+    }
+}
+
 /// Layout properties for a `symbol` layer.
 #[derive(Debug, Clone, PartialEq, Deserialize, Default)]
 pub struct SymbolLayout {
@@ -180,15 +234,15 @@ pub struct SymbolLayout {
 
     /// Part of the text placed nearest to the anchor. Supports expressions.
     #[serde(rename = "text-anchor", skip_serializing_if = "Option::is_none")]
-    pub text_anchor: Option<Value>,
+    pub text_anchor: Option<String>,
 
     /// Value to use for a text label. Supports expressions.
     #[serde(rename = "text-field", skip_serializing_if = "Option::is_none")]
-    pub text_field: Option<Value>,
+    pub text_field: Option<String>,
 
     /// Font stack for the glyphs. Supports expressions.
-    #[serde(rename = "text-font", skip_serializing_if = "Option::is_none")]
-    pub text_font: Option<Value>,
+    #[serde(rename = "text-font", default = "default_font")]
+    pub text_font: Vec<String>,
 
     /// If true, other symbols can be visible even if they collide with the text.
     #[serde(
@@ -248,8 +302,8 @@ pub struct SymbolLayout {
     pub text_rotation_alignment: Option<Value>,
 
     /// Font size. Supports expressions.
-    #[serde(rename = "text-size", skip_serializing_if = "Option::is_none")]
-    pub text_size: Option<Value>,
+    #[serde(rename = "text-size")]
+    pub text_size: Option<MlStyleValue<f64>>,
 
     /// Specifies how to capitalize text. Supports expressions.
     #[serde(rename = "text-transform", skip_serializing_if = "Option::is_none")]
@@ -303,7 +357,7 @@ pub struct SymbolLayer {
 
     /// Filter expression to select features from the source.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub filter: Option<Value>,
+    pub filter: Option<MlExpr>,
 
     /// Layout properties.
     #[serde(default)]
diff --git a/galileo/src/render/text/mod.rs b/galileo/src/render/text/mod.rs
@@ -134,6 +134,23 @@ impl FontWeight {
     pub const BOLD: Self = FontWeight(700);
     /// Thin font.
     pub const THIN: Self = FontWeight(300);
+    /// Extra-light (200).
+    pub const EXTRA_LIGHT: Self = FontWeight(200);
+    /// Light (300).
+    pub const LIGHT: Self = FontWeight(300);
+    /// Medium (600).
+    pub const MEDIUM: Self = FontWeight(600);
+    /// Semi-bold (650).
+    pub const SEMI_BOLD: Self = FontWeight(650);
+    /// Extra-bold (800).
+    pub const EXTRA_BOLD: Self = FontWeight(800);
+    /// Black / Heavy (900).
+    pub const BLACK: Self = FontWeight(900);
+
+    /// Creates a `FontWeight` from a raw CSS-style numeric weight value (100–900).
+    pub fn new(value: u16) -> Self {
+        Self(value)
+    }
 }
 
 impl Default for FontWeight {

Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ mod tests {`
`217`	`217`	`};`
`218`	`218`	`assert_eq!(s.id, "Labels");`
`219`	`219`	`assert!(s.layout.text_field.is_some());`
`220`		`- assert!(s.layout.text_font.is_some());`
	`220`	`+ assert_eq!(&s.layout.text_font, &["Open Sans Regular".to_string()]);`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`#[test]`