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-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::*;
 }

maplibre/src/coords.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use bytemuck_derive::{Pod, Zeroable};
-use cgmath::{AbsDiffEq, Matrix4, Point3, Vector3};
+use cgmath::{AbsDiffEq, Matrix4, Point3, Vector3, Vector4};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -21,6 +21,9 @@ use crate::{
 pub const EXTENT_UINT: u32 = 4096;
 pub const EXTENT_SINT: i32 = EXTENT_UINT as i32;
 pub const EXTENT: f64 = EXTENT_UINT as f64;
+const TOP_LEFT_EXTENT: Vector4<f64> = Vector4::new(0.0, 0.0, 0.0, 1.0);
+const BOTTOM_RIGHT_EXTENT: Vector4<f64> = Vector4::new(EXTENT, EXTENT, 0.0, 1.0);
+
 pub const TILE_SIZE: f64 = 512.0;
 pub const MAX_ZOOM: usize = 32;
 
@@ -723,24 +726,22 @@ impl Display for WorldCoords {
 
 #[cfg(test)]
 mod tests {
-    use cgmath::{Point2, Vector4};
+    use cgmath::Point2;
 
     use crate::{
         coords::{
-            Quadkey, TileCoords, ViewRegion, WorldCoords, WorldTileCoords, Zoom, ZoomLevel, EXTENT,
+            Quadkey, TileCoords, ViewRegion, WorldCoords, WorldTileCoords, Zoom, ZoomLevel,
+            BOTTOM_RIGHT_EXTENT, TOP_LEFT_EXTENT,
         },
         render::tile_view_pattern::DEFAULT_TILE_SIZE,
         style::source::TileAddressingScheme,
         util::math::Aabb2,
     };
 
-    const TOP_LEFT: Vector4<f64> = Vector4::new(0.0, 0.0, 0.0, 1.0);
-    const BOTTOM_RIGHT: Vector4<f64> = Vector4::new(EXTENT, EXTENT, 0.0, 1.0);
-
     fn to_from_world(tile: (i32, i32, ZoomLevel), zoom: Zoom) {
         let tile = WorldTileCoords::from(tile);
-        let p1 = tile.transform_for_zoom(zoom) * TOP_LEFT;
-        let p2 = tile.transform_for_zoom(zoom) * BOTTOM_RIGHT;
+        let p1 = tile.transform_for_zoom(zoom) * TOP_LEFT_EXTENT;
+        let p2 = tile.transform_for_zoom(zoom) * BOTTOM_RIGHT_EXTENT;
         println!("{p1:?}\n{p2:?}");
 
         assert_eq!(

maplibre/src/debug/cleanup_system.rs

@@ -1,12 +1,19 @@
-use crate::{context::MapContext, debug::TileDebugItem, render::render_phase::RenderPhase};
+use crate::{
+    context::MapContext,
+    debug::TileDebugItem,
+    render::render_phase::RenderPhase,
+    tcs::system::{SystemError, SystemResult},
+};
 
-pub fn cleanup_system(MapContext { world, .. }: &mut MapContext) {
+pub fn cleanup_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     let Some(debug_tile_phase) = world
         .resources
         .query_mut::<&mut RenderPhase<TileDebugItem>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     debug_tile_phase.clear();
+
+    Ok(())
 }

maplibre/src/debug/fps_system.rs

@@ -0,0 +1,15 @@
+use crate::{
+    context::MapContext,
+    tcs::system::{SystemError, SystemResult},
+    util::FPSMeter,
+};
+
+pub fn fps_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
+    let Some(fps_meter) = world.resources.get_mut::<FPSMeter>() else {
+        return Err(SystemError::Dependencies);
+    };
+
+    fps_meter.update_and_print();
+
+    Ok(())
+}