Introduce Plugin API along with Raster Tiles

.github/actions/cargo-install/action.yml

@@ -12,7 +12,7 @@ runs:
     - name:  Install binstall
       run: |
         if command -v cargo-binstall &> /dev/null; then
-          echo "binstall already found"
+          echo "binstall already found at $(command -v cargo-binstall)"
           exit 0
         fi
 
@@ -61,9 +61,13 @@ runs:
           echo "Skipping binary install"
         fi
 
-        # Upgrade
-        cargo binstall --no-confirm --force cargo-binstall
+        # Upgrade binstall to latest version
+        # Do not use symlinks because they behave weird on Windows(+Bash)
+        cargo binstall --no-confirm --force --no-symlinks cargo-binstall
+        # Use latest version to reinstall binstall
+        cargo binstall --no-confirm --force --no-symlinks cargo-binstall
       shell: bash
     - name: Install ${{ inputs.name }}
       shell: bash
-      run: cargo binstall --no-confirm --force ${{ inputs.name }}
+      # Do not use symlinks because they behave weird on Windows(+Bash)
+      run: cargo binstall --no-confirm --force --no-symlinks ${{ inputs.name }}

.github/workflows/demo-windows.yml

@@ -19,6 +19,9 @@ jobs:
       - name: Show PATH
         shell: powershell
         run: Write-Host $env:path
+      - name: Show bash PATH
+        shell: bash
+        run: echo $PATH
       - uses: actions/checkout@v3
       - name: Setup
         uses: ./.github/actions/setup

.gitignore

@@ -1,6 +1,5 @@
 # Generated by Cargo
 # will have compiled files and executables
-debug/
 target/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
@@ -28,4 +27,4 @@ perf.data*
 *flamegraph.svg
 *flamechart.svg
 
-frame_*.png
+frame_*.png

benchmarks/benches/data.rs

@@ -4,79 +4,55 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use maplibre::{
     benchmarking::io::static_tile_fetcher::StaticTileFetcher,
     coords::{TileCoords, ZoomLevel},
-    io::{
-        pipeline::{PipelineContext, PipelineProcessor, Processable},
-        tile_pipelines::{ParseTile, TessellateLayer},
-        TileRequest,
-    },
+    io::apc::{Context, IntoMessage, SendError},
     style::source::TileAddressingScheme,
+    vector::{
+        process_vector_tile, DefaultVectorTransferables, ProcessVectorContext, VectorTileRequest,
+    },
 };
 
+// https://tile.openstreetmap.org/15/17425/11365.png
 const MUNICH_COORDS: TileCoords = TileCoords {
     x: 17425,
     y: 11365,
     z: ZoomLevel::new(15u8),
 };
 
-pub struct DummyPipelineProcessor;
-
-impl PipelineProcessor for DummyPipelineProcessor {}
-
-fn parse_tile(c: &mut Criterion) {
-    let fetcher = StaticTileFetcher::new();
+pub struct DummyContext;
 
-    c.bench_function("parse", |b| {
-        b.iter(|| {
-            let request = TileRequest {
-                coords: MUNICH_COORDS
-                    .into_world_tile(TileAddressingScheme::XYZ)
-                    .unwrap(),
-                layers: HashSet::from(["boundary".to_owned(), "water".to_owned()]),
-            };
-            let data = fetcher
-                .sync_fetch_tile(&MUNICH_COORDS)
-                .unwrap()
-                .into_boxed_slice();
-            ParseTile::default()
-                .process(
-                    (request, data),
-                    &mut PipelineContext::new(DummyPipelineProcessor),
-                )
-                .unwrap();
-        })
-    });
+impl Context for DummyContext {
+    fn send<T: IntoMessage>(&self, _message: T) -> Result<(), SendError> {
+        Ok(())
+    }
 }
 
-fn tessellate_tile(c: &mut Criterion) {
+fn bench_process_vector_tile(c: &mut Criterion) {
     let fetcher = StaticTileFetcher::new();
-    let request = TileRequest {
-        coords: MUNICH_COORDS
-            .into_world_tile(TileAddressingScheme::XYZ)
-            .unwrap(),
-        layers: HashSet::from(["boundary".to_owned(), "water".to_owned()]),
-    };
-    let data = fetcher
-        .sync_fetch_tile(&MUNICH_COORDS)
-        .unwrap()
-        .into_boxed_slice();
-    let parsed = ParseTile::default()
-        .process(
-            (request, data),
-            &mut PipelineContext::new(DummyPipelineProcessor),
-        )
-        .unwrap();
 
-    c.bench_function("tessselate", |b| {
+    c.bench_function("process_vector_tile", |b| {
+        let data = fetcher
+            .sync_fetch_tile(&MUNICH_COORDS)
+            .unwrap()
+            .into_boxed_slice();
+
         b.iter(|| {
-            TessellateLayer::default()
-                .process(
-                    parsed.clone(),
-                    &mut PipelineContext::new(DummyPipelineProcessor),
-                )
-                .unwrap();
+            let _ = process_vector_tile(
+                &data,
+                VectorTileRequest {
+                    coords: MUNICH_COORDS
+                        .into_world_tile(TileAddressingScheme::XYZ)
+                        .unwrap(),
+                    layers: HashSet::from([
+                        "transportation".to_owned(),
+                        "water".to_owned(),
+                        "building".to_owned(),
+                    ]),
+                },
+                &mut ProcessVectorContext::<DefaultVectorTransferables, _>::new(DummyContext),
+            );
         })
     });
 }
 
-criterion_group!(benches, parse_tile, tessellate_tile);
+criterion_group!(benches, bench_process_vector_tile);
 criterion_main!(benches);

benchmarks/benches/render.rs

@@ -1,33 +1,40 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use maplibre::{
     coords::{WorldTileCoords, ZoomLevel},
-    headless::{create_headless_renderer, map::HeadlessMap},
+    headless::{create_headless_renderer, map::HeadlessMap, HeadlessPlugin},
     platform::run_multithreaded,
+    plugin::Plugin,
+    render::RenderPlugin,
     style::Style,
+    vector::{DefaultVectorTransferables, VectorPlugin},
 };
 
 fn headless_render(c: &mut Criterion) {
     c.bench_function("headless_render", |b| {
-        let (mut map, tile) = run_multithreaded(async {
+        let (mut map, layer) = run_multithreaded(async {
             let (kernel, renderer) = create_headless_renderer(1000, None).await;
             let style = Style::default();
-            let map = HeadlessMap::new(style, renderer, kernel, false).unwrap();
+
+            let plugins: Vec<Box<dyn Plugin<_>>> = vec![
+                Box::new(RenderPlugin::default()),
+                Box::new(VectorPlugin::<DefaultVectorTransferables>::default()),
+                Box::new(HeadlessPlugin::new(false)),
+            ];
+
+            let map = HeadlessMap::new(style, 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
-                .expect("Failed to process!");
+            let tile = map.process_tile(tile, &["water"]).await;
 
             (map, tile)
         });
 
         b.iter(|| {
-            map.render_tile(tile.clone());
+            map.render_tile(layer.clone());
         });
     });
 }

maplibre-build-tools/src/wgsl.rs

@@ -26,7 +26,7 @@ impl From<std::io::Error> for WgslError {
 impl WgslError {
     pub fn from_parse_err(err: ParseError, src: &str) -> Self {
         let location = err.location(src);
-        let error = err.emit_to_string(src);
+        let error = err.message().to_string();
         Self::ParserErr { error, location }
     }
 }

maplibre-demo/Cargo.toml

@@ -13,10 +13,11 @@ authors.workspace = true
 [features]
 web-webgl = ["maplibre/web-webgl"]
 trace = ["maplibre/trace"]
+headless = ["maplibre/headless"]
 
 [dependencies]
 env_logger = "0.10.0"
-maplibre = { path = "../maplibre", version = "0.1.0", features = ["headless", "thread-safe-futures"]  }
+maplibre = { path = "../maplibre", version = "0.1.0", features = ["thread-safe-futures"]  }
 maplibre-winit = { path = "../maplibre-winit", version = "0.1.0"  }
 
 tile-grid = "0.3"

maplibre-demo/src/headless.rs

@@ -1,8 +1,12 @@
 use maplibre::{
     coords::{LatLon, WorldTileCoords},
-    headless::{create_headless_renderer, map::HeadlessMap},
+    headless::{create_headless_renderer, map::HeadlessMap, HeadlessPlugin},
+    plugin::Plugin,
+    raster::{DefaultRasterTransferables, RasterPlugin},
+    render::RenderPlugin,
     style::Style,
     util::grid::google_mercator,
+    vector::{DefaultVectorTransferables, VectorPlugin},
 };
 use tile_grid::{extent_wgs84_to_merc, Extent, GridIterator};
 
@@ -17,7 +21,14 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
         .map(|layer| layer.source_layer.as_ref().unwrap().clone())
         .collect::<Vec<_>>();
 
-    let mut map = HeadlessMap::new(style, renderer, kernel, true).unwrap();
+    let plugins: Vec<Box<dyn Plugin<_>>> = vec![
+        Box::new(RenderPlugin::default()),
+        Box::new(VectorPlugin::<DefaultVectorTransferables>::default()),
+        Box::new(RasterPlugin::<DefaultRasterTransferables>::default()),
+        Box::new(HeadlessPlugin::new(true)),
+    ];
+
+    let mut map = HeadlessMap::new(style, renderer, kernel, plugins).unwrap();
 
     let tile_limits = google_mercator().tile_limits(
         extent_wgs84_to_merc(&Extent {
@@ -35,17 +46,16 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
 
         let tile = map.fetch_tile(coords).await.expect("Failed to fetch!");
 
-        let tile = map
+        let layers = map
             .process_tile(
                 tile,
                 &requested_layers
                     .iter()
                     .map(|layer| layer.as_str())
                     .collect::<Vec<_>>(),
             )
-            .await
-            .expect("Failed to process!");
+            .await;
 
-        map.render_tile(tile);
+        map.render_tile(layers);
     }
 }

maplibre-demo/src/main.rs

@@ -2,12 +2,11 @@
 
 use std::io::ErrorKind;
 
-use clap::{builder::ValueParser, Parser, Subcommand};
-use maplibre::{coords::LatLon, platform::run_multithreaded};
+use clap::{Parser, Subcommand};
+use maplibre::coords::LatLon;
 use maplibre_winit::run_headed_map;
 
-use crate::headless::run_headless;
-
+#[cfg(feature = "headless")]
 mod headless;
 
 #[derive(Parser)]
@@ -36,16 +35,17 @@ fn parse_lat_long(env: &str) -> Result<LatLon, std::io::Error> {
 #[derive(Subcommand)]
 enum Commands {
     Headed {},
+    #[cfg(feature = "headless")]
     Headless {
         #[clap(default_value_t = 400)]
         tile_size: u32,
         #[clap(
-            value_parser = ValueParser::new(parse_lat_long),
+            value_parser = clap::builder::ValueParser::new(parse_lat_long),
             default_value_t = LatLon::new(48.0345697188, 11.3475219363)
         )]
         min: LatLon,
         #[clap(
-            value_parser = ValueParser::new(parse_lat_long),
+            value_parser = clap::builder::ValueParser::new(parse_lat_long),
             default_value_t = LatLon::new(48.255861, 11.7917815798)
         )]
         max: LatLon,
@@ -64,12 +64,15 @@ fn main() {
     // matches just as you would the top level cmd
     match &cli.command {
         Commands::Headed {} => run_headed_map(None),
+        #[cfg(feature = "headless")]
         Commands::Headless {
             tile_size,
             min,
             max,
         } => {
-            run_multithreaded(async { run_headless(*tile_size, *min, *max).await });
+            maplibre::platform::run_multithreaded(async {
+                headless::run_headless(*tile_size, *min, *max).await
+            });
         }
     }
 }

maplibre-winit/src/input/pan_handler.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::{EuclideanSpace, Point3, Vector2, Vector3, Zero};
-use maplibre::{context::MapContext, render::camera::Camera, world::World};
+use maplibre::{context::MapContext, render::camera::Camera};
 use winit::event::{ElementState, MouseButton};
 
 use super::UpdateState;
@@ -15,14 +15,7 @@ pub struct PanHandler {
 }
 
 impl UpdateState for PanHandler {
-    fn update_state(
-        &mut self,
-        MapContext {
-            world: World { view_state, .. },
-            ..
-        }: &mut MapContext,
-        _dt: Duration,
-    ) {
+    fn update_state(&mut self, MapContext { view_state, .. }: &mut MapContext, _dt: Duration) {
         if !self.is_panning {
             return;
         }