feat: implement continuous mode

Cargo.toml

@@ -66,7 +66,7 @@ axum = "0.8"
 clap = { version = "4.5.27", features = ["derive", "env", "unstable-markdown"] }
 cmake = "0.1"
 cxx = "1.0.138"
-cxx-build = "1.0.138"
+cxx-build = "1.0.138" # TODO: required to be a dependency and not only a build dependency?
 downloader = "0.2.8"
 env_logger = "0.11"
 flate2 = "1.1.1"

README.md

@@ -32,8 +32,8 @@ We also support the following other features:
 At its core, we work as follows:
 
 ```rust
-use maplibre_native::{ImageRendererOptions, Image};
-let mut renderer = ImageRendererOptions::new();
+use maplibre_native::{ImageRendererBuilder, Image};
+let mut renderer = ImageRendererBuilder::new();
 renderer.with_size(512, 512);
 let mut renderer = renderer.build_static_renderer();
 renderer.load_style_from_url(&"https://demotiles.maplibre.org/style.json".parse().unwrap());

build.rs

@@ -1,4 +1,14 @@
 //! File for defining how we download and link against `MapLibre Native`.
+//! Set `MLN_CORE_LIBRARY_PATH` and `MLN_CORE_LIBRARY_HEADERS_PATH` environment variables to use a local version of maplibre
+//!
+//! If you don't use the AMALGAM library define the env variable `MLN_CORE_LIBRARY_NO_AMALGAM` (value does not matter).
+//! In this case all dependend libraries get linked manually
+//!
+//! IMPORTANT: The library path must point to the amalgan library which contains all the dependent libraries if `MLN_CORE_LIBRARY_NO_AMALGAM` is not set!
+//!
+//! Required libraries:
+//! Fedora:
+//!     - `sudo dnf install libicu-devel libglslang-devel spirv-tools-devel libpng-devel libjpeg-turbo-devel libuv-devel libwebp-devel`
 
 use std::path::{Path, PathBuf};
 use std::{env, fs};
@@ -160,14 +170,22 @@ fn resolve_mln_core(root: &Path) -> (PathBuf, Vec<PathBuf>) {
      };
     assert!(
         library_file.is_file(),
-        "The MLN library at {} must be a file",
+        "The MLN library at {} must be a file. When building locally on Linux it is called libmbgl-core.a",
         library_file.display()
     );
-    assert!(
-        headers.is_file(),
-        "The MLN headers at {} must be a zip file containing the headers",
-        headers.display()
-    );
+    if env::var_os("MLN_CORE_LIBRARY_HEADERS_PATH").is_some() {
+        assert!(
+            headers.is_file(),
+            "The MLN headers at {} must be a gzip (tar.gz) file containing the headers. When building locally checkout <maplibre-native repository>/.github/workflows/core-release.yml commands how to create the header archive",
+            headers.display()
+        );
+    } else {
+        assert!(
+            headers.is_file(),
+            "The MLN headers at {} must be a zip file containing the headers.",
+            headers.display()
+        );
+    }
 
     let extracted_path = out_dir.join("headers");
     extract_headers(&headers, &extracted_path);
@@ -199,6 +217,8 @@ fn resolve_mln_core(root: &Path) -> (PathBuf, Vec<PathBuf>) {
 fn build_bridge(lib_name: &str, include_dirs: &[PathBuf]) {
     println!("cargo:rerun-if-changed=src/renderer/bridge.rs");
     println!("cargo:rerun-if-changed=include/map_renderer.h");
+    println!("cargo:rerun-if-changed=include/renderer_observer.h");
+    println!("cargo:rerun-if-changed=include/map_observer.h");
     println!("cargo:rerun-if-changed=include/rust_log_observer.h");
     cxx_build::bridge("src/renderer/bridge.rs")
         .includes(include_dirs)
@@ -213,6 +233,10 @@ fn build_bridge(lib_name: &str, include_dirs: &[PathBuf]) {
 fn build_mln() {
     let root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
     let (cpp_root, include_dirs) = resolve_mln_core(&root);
+
+    println!("cargo:rerun-if-env-changed=MLN_CORE_LIBRARY_NO_AMALGAM");
+    let no_amalgam_lib = env::var_os("MLN_CORE_LIBRARY_NO_AMALGAM").is_some();
+
     println!(
         "cargo:warning=Using precompiled maplibre-native static library from {}",
         cpp_root.display()
@@ -261,7 +285,39 @@ fn build_mln() {
         .replacen("lib", "", 1)
         .replace(".a", "");
     build_bridge(&lib_name, &include_dirs);
-
+    if no_amalgam_lib {
+        // The dependent libs are not bundled in the core lib, so we have to link manually
+        // Required for mlt-cpp. Cpp root link search was already added above
+        println!(
+            "cargo:rustc-link-search=native={}",
+            cpp_root
+                .parent()
+                .unwrap()
+                .join("vendor")
+                .join("maplibre-tile-spec")
+                .join("cpp")
+                .display()
+        );
+        println!("cargo:rustc-link-lib=mbgl-harfbuzz");
+        println!("cargo:rustc-link-lib=mbgl-freetype");
+        println!("cargo:rustc-link-lib=mbgl-vendor-nunicode");
+        println!("cargo:rustc-link-lib=mbgl-vendor-parsedate");
+        println!("cargo:rustc-link-lib=mbgl-vendor-sqlite");
+        println!("cargo:rustc-link-lib=mbgl-vendor-csscolorparser");
+        println!("cargo:rustc-link-lib=mlt-cpp"); // provided with matlibre-native
+                                                  // println!("cargo:rustc-link-lib=utf8proc"); // sudo dnf install utf8proc-devel
+        println!("cargo:rustc-link-lib=icuuc"); //sudo dnf install libicu-devel
+        println!("cargo:rustc-link-lib=icudata"); //sudo dnf install libicu-devel
+        println!("cargo:rustc-link-lib=icui18n"); //sudo dnf install libicu-devel
+        println!("cargo:rustc-link-lib=glslang"); //sudo dnf install libglslang-devel
+        println!("cargo:rustc-link-lib=glslang-default-resource-limits"); //sudo dnf install libglslang-devel
+        println!("cargo:rustc-link-lib=SPIRV-Tools"); //sudo dnf install  spirv-tools-devel // Required by glslang spirv-tools-devel
+        println!("cargo:rustc-link-lib=SPIRV-Tools-opt"); //sudo dnf install  spirv-tools-devel // Required by glslang spirv-tools-devel
+        println!("cargo:rustc-link-lib=png"); // sudo dnf install libpng-devel
+        println!("cargo:rustc-link-lib=jpeg"); // sudo dnf install libjpeg-turbo-devel
+        println!("cargo:rustc-link-lib=uv"); // sudo dnf install libuv-devel
+        println!("cargo:rustc-link-lib=webp"); // sudo dnf install libwebp-devel
+    }
     println!("cargo:rustc-link-lib=curl");
     println!("cargo:rustc-link-lib=z");
     match GraphicsRenderingAPI::from_selected_features() {

examples/slint/.gitignore

@@ -0,0 +1,2 @@
+target
+maplibre_database.sqlite

examples/slint/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "slint_map_libre_native"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+slint = { version = "1.15", features = ["backend-android-activity-06"] }
+maplibre_native = { path = "../.."}
+
+[build-dependencies]
+slint-build = { version = "1.15"  }

examples/slint/Readme.md

@@ -0,0 +1,3 @@
+# Slint Loves MapLibre
+
+This example shows how MapLibre can be used in Slint.

examples/slint/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    slint_build::compile("main.slint").expect("Slint build failed");
+}

examples/slint/main.slint

@@ -0,0 +1,100 @@
+import { Button, VerticalBox, ComboBox, HorizontalBox, Slider } from "std-widgets.slint";
+import { MaterialWindow, MaterialWindowAdapter, ListItem } from "dependencies/slint/ui-libraries/material/src/material.slint";
+
+
+// Define a struct to hold window size
+export struct Size {
+    width: length,
+    height: length,
+}
+
+// TODO: make this not global, because then it can be used only for one instance!
+export global MapAdapter {
+    in-out property <image> map_texture;
+    callback tick_map_loop();
+    callback mouse_press(x: float, y: float);
+    callback mouse_release(y: float, x: float);
+    callback mouse_move(x: float, y: float, bool);
+    callback style_changed(style: string);
+    callback double_click_with_shift(x: float, y: float, shift_pressed: bool);
+    callback wheel_zoom(x: float, y: float, zoom_delta: float); // Positive delta_y: zoom out; Negative: zoom in
+    callback fly_to(location: string);
+    callback pitch_changed(int);
+    callback bearing_changed(float);
+}
+
+export component MapWidget inherits Rectangle {
+    // Default size
+    background: green;
+
+    // Expose map image area size so backend can match framebuffer size
+    out property<Size> map-size: { width: map.width, height: map.height };
+    callback map-size-changed(Size);
+    changed map-size => {
+        debug("Map size changed", map-size);
+        map-size-changed(map-size);
+    }
+
+    Timer {
+        interval: 16ms;
+        running: true;
+        triggered => {
+            MapAdapter.tick_map_loop();
+        }
+    }
+
+    VerticalBox {
+        spacing: 0px;
+
+        map := Image {
+            source: MapAdapter.map_texture;
+            image-fit: preserve; // Otherwise the mouse move is not correctly
+            vertical-alignment: center;
+            horizontal-alignment: center;
+
+            touch := TouchArea {
+                // Track last seen Shift modifier state from pointer events
+                property <bool> last-shift: false;
+                mouse-cursor: self.pressed ? grabbing : grab;
+
+                // Handle all pointer events properly
+                pointer-event(e) => {
+                    self.last-shift = e.modifiers.shift;
+
+                    if (e.kind == PointerEventKind.down) {
+                        MapAdapter.mouse_press(self.mouse-x / 1px, self.mouse-y / 1px);
+                    } else if (e.kind == PointerEventKind.up) {
+                        MapAdapter.mouse_release(self.mouse-x / 1px, self.mouse-y / 1px);
+                    } else if (e.kind == PointerEventKind.move && self.pressed) {
+                        MapAdapter.mouse_move(self.mouse-x / 1px, self.mouse-y / 1px, true);
+                    }
+                }
+
+                // Mouse-wheel / trackpad scroll to zoom
+                scroll-event(event) => {
+                    MapAdapter.wheel_zoom(self.mouse-x / 1px,
+                                        self.mouse-y / 1px,
+                                        event.delta_y / 1px);
+                    return accept;
+                }
+            }
+        }
+    }
+}
+
+export component MainWindow inherits MaterialWindow {
+    callback map-size-changed <=> map.map-size-changed;
+    out property <Size> map-size <=> map.map-size;
+
+    preferred-width: 800px;
+    preferred-height: 600px;
+
+    init => {
+        debug("MainWindow width: ", self.width, ", Height: ", self.height);
+    }
+
+    map:= MapWidget {
+        width: root.width;
+        height: root.height;
+    }
+}

examples/slint/src/main.rs

@@ -0,0 +1,16 @@
+mod maplibre;
+
+use std::sync::Arc;
+
+slint::include_modules!();
+
+fn main() {
+    let ui = MainWindow::new().unwrap();
+
+    let size = ui.get_map_size();
+    let map = maplibre::create_map(size);
+
+    maplibre::init(&ui, &map);
+
+    ui.run().unwrap();
+}

examples/slint/src/maplibre.rs

@@ -0,0 +1,89 @@
+use crate::MainWindow;
+use crate::MapAdapter;
+use maplibre_native::Height;
+use maplibre_native::ScreenCoordinate;
+use maplibre_native::Width;
+use slint::ComponentHandle;
+use std::sync::Arc;
+mod headless;
+use headless::MapLibre;
+pub use headless::create_map;
+use maplibre_native::{X, Y};
+use std::cell::RefCell;
+
+pub fn init(ui: &MainWindow, map: &Arc<RefCell<MapLibre>>) {
+    ui.on_map_size_changed({
+        let map = Arc::downgrade(map);
+        move |size| {
+            let size =
+                maplibre_native::Size::new(Width(size.width as u32), Height(size.height as u32));
+            map.upgrade()
+                .unwrap()
+                .borrow_mut()
+                .renderer()
+                .set_map_size(size);
+        }
+    });
+
+    ui.global::<MapAdapter>().on_tick_map_loop({
+        let map = Arc::downgrade(map);
+        let ui_handle = ui.as_weak();
+        move || {
+            let map = map.upgrade().unwrap();
+            let mut map = map.borrow_mut();
+            map.renderer().render_once();
+            if map.updated() {
+                let image = map.renderer().read_still_image();
+                let size = image.size();
+                let img = slint::SharedPixelBuffer::<slint::Rgba8Pixel>::clone_from_slice(
+                    image.buffer(),
+                    size.width(),
+                    size.height(),
+                );
+                println!("New image: ({}, {})", size.width(), size.height());
+                ui_handle
+                    .upgrade()
+                    .unwrap()
+                    .global::<MapAdapter>()
+                    .set_map_texture(slint::Image::from_rgba8(img)); // TODO: check if the image really changed, otherwise we don't need to clone!
+            }
+        }
+    });
+
+    ui.global::<MapAdapter>().on_mouse_press({
+        let map = Arc::downgrade(map);
+        move |x: f32, y: f32| {
+            map.upgrade()
+                .unwrap()
+                .borrow_mut()
+                .set_position(ScreenCoordinate::new(X(x.into()), Y(y.into())));
+        }
+    });
+
+    ui.global::<MapAdapter>().on_mouse_move({
+        let map = Arc::downgrade(map);
+        move |x: f32, y: f32, _z: bool| {
+            println!("Mouse move");
+            let p = ScreenCoordinate::new(X(x.into()), Y(y.into()));
+            let map = map.upgrade().unwrap();
+            let mut map = map.borrow_mut();
+            let delta = p - map.position();
+            map.renderer().move_by(delta);
+            map.set_position(p);
+        }
+    });
+
+    ui.global::<MapAdapter>().on_wheel_zoom({
+        let map = Arc::downgrade(map);
+        move |x: f32, y: f32, delta: f32| {
+            const STEP: f64 = 1.2;
+            let pos = ScreenCoordinate::new(X(x.into()), Y(y.into()));
+            let scale = if delta > 0. { STEP } else { 1.0 / STEP };
+            map.upgrade()
+                .unwrap()
+                .borrow_mut()
+                .renderer()
+                .scale_by(scale, pos);
+        }
+    });
+}