Fix compilation issues

maplibre-winit/src/noweb.rs

@@ -10,7 +10,7 @@ use maplibre::{
     kernel::{Kernel, KernelBuilder},
     map::Map,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
-    render::builder::RenderBuilder,
+    render::builder::{InitializedRenderer, RenderBuilder},
     style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
 };
@@ -82,19 +82,23 @@ pub fn run_headed_map(cache_path: Option<String>) {
             .with_scheduler(TokioScheduler::new())
             .build();
 
-        let uninitialized = RenderBuilder::new()
+        let InitializedRenderer {
+            mut window,
+            renderer,
+        } = RenderBuilder::new()
             .build()
             .initialize_with(&kernel)
             .await
-            .expect("Failed to initialize renderer");
-        let result = uninitialized.unwarp();
+            .expect("Failed to initialize renderer")
+            .unwarp();
 
-        let mut window = result.window;
-        let renderer = result.renderer;
-        window.event_loop.take().unwrap().run(
-            window,
-            Map::new(Style::default(), kernel, renderer).unwrap(),
-            None,
-        )
+        window
+            .take_event_loop()
+            .expect("Event loop is not available")
+            .run(
+                window,
+                Map::new(Style::default(), kernel, renderer).unwrap(),
+                None,
+            )
     })
 }

maplibre/src/headless/map.rs

@@ -139,12 +139,13 @@ impl PipelineProcessor for HeadlessPipelineProcessor {
         buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
         feature_indices: Vec<u32>,
         layer_data: RawLayer,
-    ) {
+    ) -> Result<(), Error> {
         self.layers.push(StoredLayer::TessellatedLayer {
             coords: *coords,
             layer_name: layer_data.name,
             buffer,
             feature_indices,
-        })
+        });
+        Ok(())
     }
 }

maplibre/src/io/tile_pipelines.rs

@@ -97,7 +97,7 @@ impl Processable for TessellateLayer {
                     tessellator.buffer.into(),
                     tessellator.feature_indices,
                     cloned_layer,
-                )
+                );
             }
         }
 

maplibre/src/stages/mod.rs

@@ -89,11 +89,12 @@ impl<'c, T: Transferables, HC: HttpClient, C: Context<T, HC>> PipelineProcessor
         &mut self,
         coords: &WorldTileCoords,
         geometries: Vec<IndexedGeometry<f64>>,
-    ) {
+    ) -> Result<(), Error> {
         // FIXME (wasm-executor): Readd
         /*        if let Ok(mut geometry_index) = self.state.geometry_index.lock() {
             geometry_index.index_tile(coords, TileIndex::Linear { list: geometries })
         }*/
+        Ok(())
     }
 }
 

web/src/lib.rs

@@ -63,7 +63,6 @@ pub type MapType = Map<
 
 #[wasm_bindgen]
 pub async fn create_map(new_worker: js_sys::Function) -> u32 {
-    // Either call forget or the main loop to keep worker loop alive
     let mut builder = MapBuilder::new()
         .with_map_window_config(WinitMapWindowConfig::new("maplibre".to_string()))
         .with_http_client(WHATWGFetchHttpClient::new());
@@ -97,9 +96,8 @@ pub async fn create_map(new_worker: js_sys::Function) -> u32 {
 #[wasm_bindgen]
 pub unsafe fn clone_map(map_ptr: *const RefCell<MapType>) -> *const RefCell<MapType> {
     let mut map = Rc::from_raw(map_ptr);
-    let rc = map.clone();
-    let cloned = Rc::into_raw(rc);
-    mem::forget(map);
+    let cloned = Rc::into_raw(map.clone());
+    mem::forget(map); // TODO: Enforce forget, else the map gets dropped after calling such a function
     cloned
 }