Initial demotiles support (#333)

Author: birkskyum

.gitignore

@@ -15,6 +15,9 @@ Cargo.lock
 dist/
 
 maplibre-gl-js/
+render-tests/**/diff.png
+render-tests/**/actual.png
+maplibre-native-shaders/
 
 # Cache by reqwest-middleware-cache
 *reqwest*cache*

Cargo.toml.test

@@ -0,0 +1,7 @@
+[package]
+name = "test_column"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+geozero = "0.11"

maplibre/src/background/queue_system.rs

@@ -34,11 +34,10 @@ pub fn queue_system(
     // We just iterate through the style layers and issue a single quad draw for each background layer.
     for layer in &style.layers {
         if layer.type_ == "background" {
-            let c = match &layer.paint {
-                Some(LayerPaint::Background(paint)) => paint
-                    .background_color
-                    .as_ref()
-                    .map(|c| c.to_array())
+            let c: [f32; 4] = match &layer.paint {
+                Some(paint @ LayerPaint::Background(_)) => paint
+                    .get_color()
+                    .map(|c| c.into())
                     .unwrap_or([0.0, 0.0, 0.0, 1.0]),
                 _ => [0.0, 0.0, 0.0, 1.0],
             };
@@ -50,6 +49,7 @@ pub fn queue_system(
                 draw_function: Box::new(DrawState::<LayerItem, DrawBackground>::new())
                     as Box<dyn crate::render::render_phase::Draw<LayerItem>>,
                 index: layer.index,
+                is_line: false,
                 style_layer: layer.id.clone(),
                 source_shape: crate::render::tile_view_pattern::TileShape::default(),
 

maplibre/src/coords.rs

@@ -201,6 +201,10 @@ impl Zoom {
     pub fn new(zoom: f64) -> Self {
         Zoom(zoom)
     }
+
+    pub fn level(&self) -> f32 {
+        self.0 as f32
+    }
 }
 
 impl Zoom {

maplibre/src/geojson/mod.rs

@@ -67,7 +67,19 @@ impl<T> ProjectingTessellator<T> {
 
 impl<T: GeomProcessor> GeomProcessor for ProjectingTessellator<T> {
     fn xy(&mut self, x: f64, y: f64, idx: usize) -> geozero::error::Result<()> {
+        if x.is_nan() || y.is_nan() {
+            println!(
+                "ProjectingTessellator received NaN Input! x={}, y={}, idx={}",
+                x, y, idx
+            );
+        }
         let (tx, ty) = self.project(x, y);
+        if !tx.is_finite() || !ty.is_finite() {
+            println!(
+                "ProjectingTessellator output non-finite! lon={}, lat={} -> tx={}, ty={}",
+                x, y, tx, ty
+            );
+        }
         self.inner.xy(tx, ty, idx)
     }
 
@@ -210,12 +222,22 @@ pub fn process_geojson_features<T: VectorTransferables, C: Context>(
         };
 
         match paint {
-            LayerPaint::Fill(_) | LayerPaint::Line(_) => {
-                let mut projecting = ProjectingTessellator::new(
-                    coords,
-                    request.project,
-                    ZeroTessellator::<IndexDataType>::default(),
-                );
+            LayerPaint::Fill(_) | LayerPaint::Line(_) | LayerPaint::Background(_) => {
+                let mut tessellator = ZeroTessellator::<IndexDataType>::default();
+                match paint {
+                    LayerPaint::Fill(p) => tessellator.style_property = p.fill_color.clone(),
+                    LayerPaint::Line(p) => {
+                        tessellator.style_property = p.line_color.clone();
+                        tessellator.is_line_layer = true;
+                    }
+                    LayerPaint::Background(p) => {
+                        tessellator.style_property = p.background_color.clone()
+                    }
+                    _ => {}
+                }
+
+                let mut projecting =
+                    ProjectingTessellator::new(coords, request.project, tessellator);
 
                 let mut geojson_src = geozero::geojson::GeoJson(json_str.as_str());
                 if let Err(e) = geojson_src.process(&mut projecting) {
@@ -249,7 +271,9 @@ pub fn process_geojson_features<T: VectorTransferables, C: Context>(
                         coords,
                         inner.buffer.into(),
                         inner.feature_indices,
+                        inner.feature_colors,
                         synthetic_layer,
+                        style_layer.id.clone(),
                     ))
                     .map_err(ProcessGeoJsonError::SendError)?;
             }
@@ -291,6 +315,7 @@ pub fn process_geojson_features<T: VectorTransferables, C: Context>(
                         inner.quad_buffer.into(),
                         inner.features,
                         synthetic_layer,
+                        style_layer.id.clone(),
                     ))
                     .map_err(ProcessGeoJsonError::SendError)?;
             }

maplibre/src/headless/map.rs

@@ -90,8 +90,10 @@ impl HeadlessMap {
                         VectorLayerBucket::AvailableLayer(AvailableVectorLayerBucket {
                             coords: layer.coords,
                             source_layer: layer.layer_data.name,
+                            style_layer_id: layer.style_layer_id,
                             buffer: layer.buffer,
                             feature_indices: layer.feature_indices,
+                            feature_colors: layer.feature_colors,
                         })
                     })
                     .collect::<Vec<_>>(),

maplibre/src/io/source_type.rs

@@ -31,6 +31,7 @@ impl TessellateSource {
 impl Default for TessellateSource {
     fn default() -> Self {
         Self::new("https://maps.tuerantuer.org/europe_germany", "pbf")
+        // Self::new("https://demotiles.maplibre.org/tiles", "pbf")
     }
 }
 

maplibre/src/raster/queue_system.rs

@@ -36,6 +36,7 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
                 LayerItem {
                     draw_function: Box::new(DrawState::<LayerItem, DrawRasterTiles>::new()),
                     index: 0,
+                    is_line: false,
                     style_layer: "raster".to_string(),
                     tile: Tile {
                         coords: source_shape.coords(),

maplibre/src/render/main_pass.rs

@@ -115,6 +115,11 @@ impl Node for MainPassNode {
 
         if let Some(layer_items) = world.resources.get::<RenderPhase<LayerItem>>() {
             log::trace!("RenderPhase<LayerItem>::size() = {}", layer_items.size());
+
+            // Draw layers in style index order (painter's algorithm).
+            // This preserves the MapLibre GL JS rendering model where e.g.
+            // coastline (line) → countries-fill (fill) → countries-boundary (line)
+            // ensures fill covers inland portions of coastline.
             for item in layer_items {
                 item.draw_function.draw(&mut tracked_pass, world, item);
             }

maplibre/src/render/render_phase/mod.rs

@@ -49,6 +49,8 @@ impl<I: PhaseItem> RenderPhase<I> {
 pub struct LayerItem {
     pub draw_function: Box<dyn Draw<LayerItem>>,
     pub index: u32,
+    /// Whether this item uses the line pipeline (true) or fill pipeline (false).
+    pub is_line: bool,
 
     pub style_layer: String,