SDF text rendering plugin

Cargo.toml

@@ -68,15 +68,16 @@ tokio = "1.32.0"  # Individual features are customized in each crate
 tokio-util = { version = "0.7.9", features = ["rt"] }
 tracing = "0.1.37"
 tracing-subscriber = "0.3.17"
-tracing-tracy = "0.11.1"
+tracing-tracy = "=0.10.5"
 tracing-wasm = "0.2.1"  # TODO: Low quality dependency (remove in a separate PR!)
 walkdir = "2.4.0"
 wasm-bindgen = "=0.2.92"
 wasm-bindgen-futures = "0.4"
 wasm-bindgen-test = "0.3"
 web-sys = "0.3"  # Individual features are customized in each crate
-wgpu = "22.0.0"
+wgpu = "22.1.0"
 http-cache-reqwest = "0.14.0"
+bitflags = "2.6.0"
 
 [profile.release]
 lto = true

benchmarks/benches/data.rs

@@ -5,7 +5,7 @@ use maplibre::{
     benchmarking::io::static_tile_fetcher::StaticTileFetcher,
     coords::{TileCoords, ZoomLevel},
     io::apc::{Context, IntoMessage, SendError},
-    style::source::TileAddressingScheme,
+    style::{source::TileAddressingScheme, Style},
     vector::{
         process_vector_tile, DefaultVectorTransferables, ProcessVectorContext, VectorTileRequest,
     },
@@ -42,11 +42,7 @@ fn bench_process_vector_tile(c: &mut Criterion) {
                     coords: MUNICH_COORDS
                         .into_world_tile(TileAddressingScheme::XYZ)
                         .unwrap(),
-                    layers: HashSet::from([
-                        "transportation".to_owned(),
-                        "water".to_owned(),
-                        "building".to_owned(),
-                    ]),
+                    layers: Style::default().layers.iter().cloned().collect(),
                 },
                 &mut ProcessVectorContext::<DefaultVectorTransferables, _>::new(DummyContext),
             );

benchmarks/benches/render.rs

@@ -21,14 +21,19 @@ fn headless_render(c: &mut Criterion) {
                 Box::new(HeadlessPlugin::new(false)),
             ];
 
-            let map = HeadlessMap::new(style, renderer, kernel, plugins).unwrap();
+            let map = HeadlessMap::new(style.clone(), renderer, kernel, plugins).unwrap();
 
             let tile = map
                 .fetch_tile(WorldTileCoords::from((0, 0, ZoomLevel::default())))
                 .await
                 .expect("Failed to fetch!");
 
-            let tile = map.process_tile(tile, &["water"]).await;
+            let water_layer = style
+                .layers
+                .iter()
+                .find(|layer| layer.source_layer == Some("water".to_string()))
+                .expect("water layer must exist");
+            let tile = map.process_tile(tile, water_layer).await;
 
             (map, tile)
         });

maplibre-build-tools/src/wgsl.rs

@@ -62,15 +62,16 @@ pub fn validate_project_wgsl() {
             Ok(entry) => {
                 let path = entry.path();
                 if !path.is_dir() {
+                    println!("cargo:rerun-if-changed={}", path.display().to_string());
                     match validate_wgsl(&mut validator, path) {
                         Ok(_) => {}
                         Err(err) => {
                             let path = path.strip_prefix(&root_dir).unwrap_or(path);
-                            println!(
-                                "cargo:warning={}{}",
+                            panic!(
+                                "{}{}",
                                 path.to_str().unwrap(),
                                 match err {
-                                    WgslError::ValidationErr(error) => format!(": {error:?}"),
+                                    WgslError::ValidationErr(error) => format!(": {error}"),
                                     WgslError::ParserErr { error, location } =>
                                         if let Some(SourceLocation {
                                             line_number,
@@ -82,10 +83,9 @@ pub fn validate_project_wgsl() {
                                         } else {
                                             error
                                         },
-                                    WgslError::IoErr(error) => format!(": {error:?}"),
+                                    WgslError::IoErr(error) => format!(": {error}"),
                                 }
                             );
-                            exit(1);
                         }
                     };
                 }

maplibre-demo/src/main.rs

@@ -17,6 +17,7 @@ struct Cli {
     command: Commands,
 }
 
+#[allow(dead_code)]
 fn parse_lat_long(env: &str) -> Result<LatLon, std::io::Error> {
     let split = env.split(',').collect::<Vec<_>>();
     if let (Some(latitude), Some(longitude)) = (split.first(), split.get(1)) {

maplibre-winit/src/input/camera_handler.rs

@@ -20,7 +20,7 @@ pub struct CameraHandler {
 }
 
 impl UpdateState for CameraHandler {
-    fn update_state(&mut self, MapContext { view_state, .. }: &mut MapContext, dt: Duration) {
+    fn update_state(&mut self, MapContext { view_state, .. }: &mut MapContext, _dt: Duration) {
         if !self.is_active {
             return;
         }

maplibre-winit/src/lib.rs

@@ -164,7 +164,7 @@ impl<ET: 'static + PartialEq + Debug> EventLoop<ET> for WinitEventLoop<ET> {
                                         }
                                     }
                                 }
-                                WindowEvent::ScaleFactorChanged { inner_size_writer, scale_factor: new_scale_factor } => {
+                                WindowEvent::ScaleFactorChanged { inner_size_writer: _, scale_factor: new_scale_factor } => {
                                     if let Ok(map_context) =  map.context_mut() {
                                         log::info!("New scaling factor: {}", new_scale_factor);
                                         scale_factor = *new_scale_factor;

maplibre-winit/src/noweb.rs

@@ -19,7 +19,7 @@ use maplibre::{
     style::Style,
     window::{MapWindow, MapWindowConfig, PhysicalSize, WindowCreateError},
 };
-use winit::window::WindowAttributes;
+use winit::{dpi::Size, window::WindowAttributes};
 
 use super::WinitMapWindow;
 use crate::{WinitEnvironment, WinitEventLoop};
@@ -87,7 +87,12 @@ impl<ET: 'static + Clone> MapWindowConfig for WinitMapWindowConfig<ET> {
             .map_err(|_| WindowCreateError::EventLoop)?;
 
         let window = raw_event_loop
-            .create_window(WindowAttributes::new().with_title(&self.title))
+            .create_window(
+                WindowAttributes::new()
+                    .with_title(&self.title)
+                    // TODO make window size configurable
+                    .with_inner_size(Size::Logical(winit::dpi::LogicalSize::new(800.0, 800.0))),
+            )
             .map_err(|_| WindowCreateError::Window)?;
 
         Ok(Self::MapWindow {
@@ -136,6 +141,9 @@ pub fn run_headed_map<P>(
                 Box::new(maplibre::vector::VectorPlugin::<
                     maplibre::vector::DefaultVectorTransferables,
                 >::default()),
+                Box::new(maplibre::sdf::SdfPlugin::<
+                    maplibre::vector::DefaultVectorTransferables,
+                >::default()),
                 // Box::new(maplibre::raster::RasterPlugin::<
                 //     maplibre::raster::DefaultRasterTransferables,
                 // >::default()),

maplibre/Cargo.toml

@@ -88,5 +88,14 @@ smallvec.workspace = true
 png = { workspace = true, optional = true }
 image = { workspace = true, optional = true }
 
+# Text/glyphs
+prost = "0.13.1"
+
+# Symbols
+bitflags = { workspace = true }
+widestring = "1.1.0"
+guillotiere = "0.6.2"
+
 [build-dependencies]
 maplibre-build-tools = { path = "../maplibre-build-tools", version = "0.1.0" }
+prost-build = "0.13.1"

maplibre/build.rs

@@ -3,6 +3,8 @@
 //! This script is built and executed just before building the package.
 //! It will validate the WGSL (WebGPU Shading Language) shaders and embed static files.
 
+use std::{fs, path::PathBuf};
+
 use maplibre_build_tools::wgsl::validate_project_wgsl;
 
 #[cfg(feature = "embed-static-tiles")]
@@ -50,9 +52,27 @@ fn embed_tiles_statically() {
     }
 }
 
+fn generate_protobuf() {
+    let proto_paths = fs::read_dir("./proto")
+        .unwrap()
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            println!(
+                "cargo:rerun-if-changed={}",
+                entry.path().display().to_string()
+            );
+            Some(entry.path())
+        })
+        .collect::<Vec<_>>();
+
+    prost_build::compile_protos(&proto_paths, &[PathBuf::from("./proto/")]).unwrap();
+}
+
 fn main() {
     validate_project_wgsl();
 
     #[cfg(feature = "embed-static-tiles")]
     embed_tiles_statically();
+
+    generate_protobuf();
 }

maplibre/proto/glyphs.proto

@@ -0,0 +1,34 @@
+// Protocol Version 1
+// Adapted from https://github.com/maplibre/maplibre-native/blob/2e3538c2fe9bcf2e3961971a0807c2d2c17a3f06/misc/proto/glyphs.proto#L4
+
+package glyphs;
+
+option optimize_for = LITE_RUNTIME;
+
+// Stores a glyph with metrics and optional SDF bitmap information.
+message glyph {
+    required uint32 id = 1;
+
+    // A signed distance field of the glyph with a border of 3 pixels.
+    optional bytes bitmap = 2;
+
+    // Glyph metrics.
+    required uint32 width = 3;
+    required uint32 height = 4;
+    required sint32 left = 5;
+    required sint32 top = 6;
+    required uint32 advance = 7;
+}
+
+// Stores fontstack information and a list of faces.
+message fontstack {
+    required string name = 1;
+    required string range = 2;
+    repeated glyph glyphs = 3;
+}
+
+message glyphs {
+    repeated fontstack stacks = 1;
+
+    extensions 16 to 8191;
+}

maplibre/src/benchmarking.rs

@@ -7,5 +7,5 @@ pub mod io {
 
 /// Re-export of the tessellation module.
 pub mod tessellation {
-    pub use crate::tessellation::*;
+    pub use crate::vector::tessellation::*;
 }