archive-gh-me/maplibre-rs
1
0
Fork 0
mirror of https://github.com/maplibre/maplibre-rs.git synced 2025-12-08 19:05:57 +00:00
Code Issues Projects Releases Wiki Activity

Fix imports, refactor builders, invert feature flag

Browse Source
This commit is contained in:
Maximilian Ammann 2022-09-25 12:10:30 +02:00
parent a6553d2193
commit f8b38dc8f2
28 changed files with 249 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
maplibre/Cargo.toml
View File

@ -9,10 +9,11 @@ description = "Native Maps for Web, Mobile and Desktop"
readme = "../README.md"
[features]
default = ["thread-safe-futures"]
web-webgl = ["wgpu/webgl"]
# Enable tracing using tracy on desktop/mobile and the chrome profiler on web
trace = ["tracing-subscriber", "tracing-tracy", "tracy-client"]
no-thread-safe-futures = []
thread-safe-futures = []
embed-static-tiles = ["maplibre-build-tools/sqlite"]
headless = ["png"]

4
maplibre/src/context.rs
View File

@ -2,12 +2,14 @@ use std::ops::Div;
use cgmath::Angle;
use crate::render::Renderer;
use crate::style::Style;
use crate::window::WindowSize;
use crate::{
coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
io::tile_repository::TileRepository,
render::camera::{Camera, Perspective, ViewProjection},
util::ChangeObserver,
Renderer, Style, WindowSize,
};
/// Stores the camera configuration.

68
maplibre/src/environment.rs
View File

@ -1,12 +1,12 @@
use crate::{
io::{
apc::AsyncProcedureCall,
transferables::{
DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
},
use crate::io::scheduler::Scheduler;
use crate::io::source_client::HttpClient;
use crate::io::{
apc::AsyncProcedureCall,
transferables::{
DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
},
HttpClient, MapWindowConfig, Scheduler,
};
use crate::window::MapWindowConfig;
pub trait Environment: 'static {
type MapWindowConfig: MapWindowConfig;
@ -17,3 +17,57 @@ pub trait Environment: 'static {
type Transferables: Transferables;
}
pub struct Kernel<E: Environment> {
map_window_config: E::MapWindowConfig,
apc: E::AsyncProcedureCall,
scheduler: E::Scheduler,
http_client: E::HttpClient,
}
pub struct KernelBuilder<E: Environment> {
map_window_config: Option<E::MapWindowConfig>,
apc: Option<E::AsyncProcedureCall>,
scheduler: Option<E::Scheduler>,
http_client: Option<E::HttpClient>,
}
impl<E: Environment> KernelBuilder<E> {
pub fn new() -> Self {
Self {
scheduler: None,
apc: None,
http_client: None,
map_window_config: None,
}
}
pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
self.map_window_config = Some(map_window_config);
self
}
pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
self.scheduler = Some(scheduler);
self
}
pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
self.apc = Some(apc);
self
}
pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
self.http_client = Some(http_client);
self
}
pub fn build(self) -> Kernel<E> {
Kernel {
scheduler: self.scheduler.unwrap(), // TODO: Remove unwrap
apc: self.apc.unwrap(), // TODO: Remove unwrap
http_client: self.http_client.unwrap(), // TODO: Remove unwrap
map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
}
}
}

7
maplibre/src/headless.rs
View File

@ -12,6 +12,12 @@ use std::{
use tokio::{runtime::Handle, task};
use wgpu::{BufferAsyncError, BufferSlice};
use crate::environment::Environment;
use crate::io::scheduler::Scheduler;
use crate::io::source_client::HttpClient;
use crate::render::Renderer;
use crate::style::Style;
use crate::window::{MapWindow, MapWindowConfig, WindowSize};
use crate::{
context::{MapContext, ViewState},
coords::{LatLon, ViewRegion, WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
@ -37,7 +43,6 @@ use crate::{
RenderState,
},
schedule::{Schedule, Stage},
Environment, HttpClient, MapWindow, MapWindowConfig, Renderer, Scheduler, Style, WindowSize,
};
pub struct HeadlessMapWindowConfig {

7
maplibre/src/io/apc.rs
View File

@ -10,6 +10,8 @@ use std::{
use serde::{Deserialize, Serialize};
use crate::io::scheduler::Scheduler;
use crate::io::source_client::HttpClient;
use crate::{
coords::WorldTileCoords,
io::{
@ -17,7 +19,6 @@ use crate::{
transferables::{DefaultTransferables, Transferables},
TileRequest,
},
Environment, HttpClient, Scheduler,
};
/// The result of the tessellation of a tile.
@ -41,9 +42,9 @@ pub trait Context<T: Transferables, HC: HttpClient>: Send + 'static {
fn source_client(&self) -> &SourceClient<HC>;
}
#[cfg(not(feature = "no-thread-safe-futures"))]
#[cfg(feature = "thread-safe-futures")]
pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + Send + 'static)>>;
#[cfg(feature = "no-thread-safe-futures")]
#[cfg(not(feature = "thread-safe-futures"))]
pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + 'static)>>;
pub type AsyncProcedure<C> = fn(input: Input, context: C) -> AsyncProcedureFuture;

4
maplibre/src/io/scheduler.rs
View File

@ -7,7 +7,7 @@ use crate::error::Error;
/// Async/await scheduler.
/// Can schedule a task from a future factory and a shared state.
pub trait Scheduler: 'static {
#[cfg(not(feature = "no-thread-safe-futures"))]
#[cfg(feature = "thread-safe-futures")]
fn schedule<T>(
&self,
future_factory: impl (FnOnce() -> T) + Send + 'static,
@ -15,7 +15,7 @@ pub trait Scheduler: 'static {
where
T: Future<Output = ()> + Send + 'static;
#[cfg(feature = "no-thread-safe-futures")]
#[cfg(not(feature = "thread-safe-futures"))]
fn schedule<T>(
&self,
future_factory: impl (FnOnce() -> T) + Send + 'static,

6
maplibre/src/io/source_client.rs
View File

@ -12,9 +12,9 @@ pub type HTTPClientFactory<HC> = dyn Fn() -> HC;
/// [https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures](https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures)
///
/// Users of this library can decide whether futures from the HTTPClient are thread-safe or not via
/// the future "no-thread-safe-futures". Tokio futures are thread-safe.
#[cfg_attr(feature = "no-thread-safe-futures", async_trait(?Send))]
#[cfg_attr(not(feature = "no-thread-safe-futures"), async_trait)]
/// the future "thread-safe-futures". Tokio futures are thread-safe.
#[cfg_attr(not(feature = "thread-safe-futures"), async_trait(?Send))]
#[cfg_attr(feature = "thread-safe-futures", async_trait)]
pub trait HttpClient: Clone + Sync + Send + 'static {
async fn fetch(&self, url: &str) -> Result<Vec<u8>, Error>;
}

222
maplibre/src/lib.rs
View File

@ -16,24 +16,6 @@
//! maplibre = "0.0.2"
//! ```
use std::{
borrow::{Borrow, BorrowMut},
cell::RefCell,
rc::Rc,
};
use crate::{
environment::Environment,
io::{scheduler::Scheduler, source_client::HttpClient},
map_schedule::InteractiveMapSchedule,
render::{
settings::{RendererSettings, WgpuSettings},
RenderState, Renderer,
},
style::Style,
window::{EventLoop, HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
};
pub mod context;
pub mod coords;
pub mod error;
@ -43,7 +25,7 @@ pub mod io;
// Exposed because of input handlers in maplibre-winit
pub mod map_schedule;
pub mod platform;
// Exposed because of camera
// TODO: Exposed because of camera
pub mod render;
pub mod style;
pub mod util;
@ -54,209 +36,13 @@ pub mod schedule;
// Exposed because of SharedThreadState
pub mod stages;
pub mod environment;
// Used for benchmarking
pub mod benchmarking;
// Internal modules
pub(crate) mod tessellation;
pub mod environment;
// Export tile format
pub use geozero::mvt::tile;
/// The [`Map`] defines the public interface of the map renderer.
// DO NOT IMPLEMENT INTERNALS ON THIS STRUCT.
pub struct Map<E: Environment> {
// FIXME (wasm-executor): Avoid RefCell, change ownership model!
map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
}
impl<E: Environment> Map<E>
where
<E::MapWindowConfig as MapWindowConfig>::MapWindow: EventLoop<E>,
{
/// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
pub fn run(&self) {
self.run_with_optionally_max_frames(None);
}
/// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
///
/// # Arguments
///
/// * `max_frames` - Maximum number of frames per second.
pub fn run_with_max_frames(&self, max_frames: u64) {
self.run_with_optionally_max_frames(Some(max_frames));
}
/// Starts the MapState Runnable with the configured event loop.
///
/// # Arguments
///
/// * `max_frames` - Optional maximum number of frames per second.
pub fn run_with_optionally_max_frames(&self, max_frames: Option<u64>) {
self.window
.borrow_mut()
.take()
.unwrap() // FIXME (wasm-executor): Remove unwrap
.run(self.map_schedule.clone(), max_frames);
}
pub fn map_schedule(&self) -> Rc<RefCell<InteractiveMapSchedule<E>>> {
self.map_schedule.clone()
}
/* pub fn map_schedule_mut(&mut self) -> &mut InteractiveMapSchedule<E> {
&mut self.map_schedule
}*/
}
/// Stores the map configuration before the map's state has been fully initialized.
pub struct UninitializedMap<E: Environment> {
scheduler: E::Scheduler,
apc: E::AsyncProcedureCall,
http_client: E::HttpClient,
style: Style,
wgpu_settings: WgpuSettings,
renderer_settings: RendererSettings,
map_window_config: E::MapWindowConfig,
}
impl<E: Environment> UninitializedMap<E>
where
<E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
{
/// Initializes the whole rendering pipeline for the given configuration.
/// Returns the initialized map, ready to be run.
pub async fn initialize(self) -> Map<E> {
let window = self.map_window_config.create();
let window_size = window.size();
#[cfg(target_os = "android")]
let renderer = None;
#[cfg(not(target_os = "android"))]
let renderer = Renderer::initialize(
&window,
self.wgpu_settings.clone(),
self.renderer_settings.clone(),
)
.await
.ok();
Map {
map_schedule: Rc::new(RefCell::new(InteractiveMapSchedule::new(
self.map_window_config,
window_size,
renderer,
self.scheduler,
self.apc,
self.http_client,
self.style,
self.wgpu_settings,
self.renderer_settings,
))),
window: RefCell::new(Some(window)),
}
}
}
#[cfg(feature = "headless")]
impl<E: Environment> UninitializedMap<E> {
pub async fn initialize_headless(self) -> headless::HeadlessMap<E> {
let window = self.map_window_config.create();
let window_size = window.size();
let renderer = Renderer::initialize_headless(
&window,
self.wgpu_settings.clone(),
self.renderer_settings.clone(),
)
.await
.expect("Failed to initialize renderer");
headless::HeadlessMap {
map_schedule: headless::HeadlessMapSchedule::new(
self.map_window_config,
window_size,
renderer,
self.scheduler,
self.http_client,
self.style,
),
window,
}
}
}
pub struct MapBuilder<E: Environment> {
scheduler: Option<E::Scheduler>,
apc: Option<E::AsyncProcedureCall>,
http_client: Option<E::HttpClient>,
style: Option<Style>,
map_window_config: Option<E::MapWindowConfig>,
wgpu_settings: Option<WgpuSettings>,
renderer_settings: Option<RendererSettings>,
}
impl<E: Environment> MapBuilder<E> {
pub fn new() -> Self {
Self {
scheduler: None,
apc: None,
http_client: None,
style: None,
map_window_config: None,
wgpu_settings: None,
renderer_settings: None,
}
}
pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
self.map_window_config = Some(map_window_config);
self
}
pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
self.renderer_settings = Some(renderer_settings);
self
}
pub fn with_wgpu_settings(mut self, wgpu_settings: WgpuSettings) -> Self {
self.wgpu_settings = Some(wgpu_settings);
self
}
pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
self.scheduler = Some(scheduler);
self
}
pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
self.apc = Some(apc);
self
}
pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
self.http_client = Some(http_client);
self
}
pub fn with_style(mut self, style: Style) -> Self {
self.style = Some(style);
self
}
/// Builds the UninitializedMap with the given configuration.
pub fn build(self) -> UninitializedMap<E> {
UninitializedMap {
scheduler: self.scheduler.unwrap(), // TODO: Remove unwrap
apc: self.apc.unwrap(), // TODO: Remove unwrap
http_client: self.http_client.unwrap(), // TODO: Remove unwrap
style: self.style.unwrap_or_default(),
wgpu_settings: self.wgpu_settings.unwrap_or_default(),
renderer_settings: self.renderer_settings.unwrap_or_default(),
map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
}
}
}

47
maplibre/src/map.rs Normal file
View File

@ -0,0 +1,47 @@
/// The [`Map`] defines the public interface of the map renderer.
// DO NOT IMPLEMENT INTERNALS ON THIS STRUCT.
pub struct Map<E: Environment> {
// FIXME (wasm-executor): Avoid RefCell, change ownership model!
map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
}
impl<E: Environment> Map<E>
where
<E::MapWindowConfig as MapWindowConfig>::MapWindow: EventLoop<E>,
{
/// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
pub fn run(&self) {
self.run_with_optionally_max_frames(None);
}
/// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
///
/// # Arguments
///
/// * `max_frames` - Maximum number of frames per second.
pub fn run_with_max_frames(&self, max_frames: u64) {
self.run_with_optionally_max_frames(Some(max_frames));
}
/// Starts the MapState Runnable with the configured event loop.
///
/// # Arguments
///
/// * `max_frames` - Optional maximum number of frames per second.
pub fn run_with_optionally_max_frames(&self, max_frames: Option<u64>) {
self.window
.borrow_mut()
.take()
.unwrap() // FIXME (wasm-executor): Remove unwrap
.run(self.map_schedule.clone(), max_frames);
}
pub fn map_schedule(&self) -> Rc<RefCell<InteractiveMapSchedule<E>>> {
self.map_schedule.clone()
}
/* pub fn map_schedule_mut(&mut self) -> &mut InteractiveMapSchedule<E> {
&mut self.map_schedule
}*/
}

6
maplibre/src/map_schedule.rs
View File

@ -1,5 +1,9 @@
use std::{cell::RefCell, marker::PhantomData, mem, rc::Rc};
use crate::environment::Environment;
use crate::render::settings::{RendererSettings, WgpuSettings};
use crate::render::Renderer;
use crate::window::{HeadedMapWindow, MapWindowConfig, WindowSize};
use crate::{
context::{MapContext, ViewState},
coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
@ -13,8 +17,6 @@ use crate::{
schedule::{Schedule, Stage},
stages::register_stages,
style::Style,
Environment, HeadedMapWindow, MapWindowConfig, Renderer, RendererSettings, WgpuSettings,
WindowSize,
};
/// Stores the state of the map, dispatches tile fetching and caching, tessellation and drawing.

3
maplibre/src/platform/noweb/http_client.rs
View File

@ -3,7 +3,8 @@ use reqwest::{Client, StatusCode};
use reqwest_middleware::ClientWithMiddleware;
use reqwest_middleware_cache::{managers::CACacheManager, Cache, CacheMode};
use crate::{error::Error, HttpClient};
use crate::error::Error;
use crate::io::source_client::HttpClient;
#[derive(Clone)]
pub struct ReqwestHttpClient {

3
maplibre/src/platform/noweb/scheduler.rs
View File

@ -1,6 +1,7 @@
use std::future::Future;
use crate::{error::Error, Scheduler};
use crate::error::Error;
use crate::io::scheduler::Scheduler;
/// Multi-threading with Tokio.
pub struct TokioScheduler;

76
maplibre/src/render/builder.rs Normal file
View File

@ -0,0 +1,76 @@
use crate::environment::Environment;
use crate::render::settings::{RendererSettings, WgpuSettings};
use crate::render::Renderer;
use crate::style::Style;
use crate::window::{HeadedMapWindow, MapWindow, MapWindowConfig};
pub struct RenderBuilder {
wgpu_settings: Option<WgpuSettings>,
renderer_settings: Option<RendererSettings>,
}
impl RenderBuilder {
pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
self.renderer_settings = Some(renderer_settings);
self
}
pub fn with_wgpu_settings(mut self, wgpu_settings: WgpuSettings) -> Self {
self.wgpu_settings = Some(wgpu_settings);
self
}
pub fn build(self) -> UninitializedRenderer {
UninitializedRenderer {
wgpu_settings: self.wgpu_settings.unwrap_or_default(),
renderer_settings: self.renderer_settings.unwrap_or_default(),
}
}
}
pub struct UninitializedRenderer {
wgpu_settings: WgpuSettings,
renderer_settings: RendererSettings,
}
impl UninitializedRenderer {
/// Initializes the whole rendering pipeline for the given configuration.
/// Returns the initialized map, ready to be run.
pub async fn initialize<MWC: MapWindowConfig>(self, map_window_config: MWC) -> Option<Renderer>
where
MWC::MapWindow: MapWindow + HeadedMapWindow,
{
let window = map_window_config.create();
#[cfg(target_os = "android")]
let renderer = None;
#[cfg(not(target_os = "android"))]
let renderer = Renderer::initialize(
&window,
self.wgpu_settings.clone(),
self.renderer_settings.clone(),
)
.await
.ok();
renderer
}
}
#[cfg(feature = "headless")]
impl UninitializedRenderer {
pub async fn initialize_headless<MWC: MapWindowConfig>(
self,
map_window_config: MWC,
) -> Option<Renderer> {
let window = map_window_config.create();
Renderer::initialize_headless(
&window,
self.wgpu_settings.clone(),
self.renderer_settings.clone(),
)
.await
.ok()
}
}

8
maplibre/src/render/mod.rs
View File

@ -32,7 +32,6 @@ use crate::{
tile_view_pattern::{TileInView, TileShape, TileViewPattern},
},
tessellation::IndexDataType,
HeadedMapWindow, MapWindow,
};
pub mod graph;
@ -49,6 +48,7 @@ mod tile_pipeline;
mod tile_view_pattern;
// Public API
pub mod builder;
pub mod camera;
pub mod eventually;
pub mod settings;
@ -60,8 +60,9 @@ use crate::render::{
graph::{EmptyNode, RenderGraph, RenderGraphError},
main_pass::{MainPassDriverNode, MainPassNode},
};
use crate::window::{HeadedMapWindow, MapWindow};
pub const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32; // Must match IndexDataType
const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32; // Must match IndexDataType
pub struct RenderState {
render_target: Eventually<TextureView>,
@ -408,6 +409,9 @@ impl Renderer {
#[cfg(test)]
mod tests {
use crate::render::settings::RendererSettings;
use crate::render::RenderState;
use crate::window::{MapWindow, MapWindowConfig, WindowSize};
use crate::{MapWindow, MapWindowConfig, WindowSize};
pub struct HeadlessMapWindowConfig {

16
maplibre/src/render/render_commands.rs
View File

@ -1,15 +1,13 @@
//! Specifies the instructions which are going to be sent to the GPU. Render commands can be concatenated
//! into a new render command which executes multiple instruction sets.
use crate::{
render::{
eventually::Eventually::Initialized,
render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
resource::{Globals, IndexEntry, TrackedRenderPass},
tile_view_pattern::{TileInView, TileShape},
INDEX_FORMAT,
},
RenderState,
use crate::render::RenderState;
use crate::render::{
eventually::Eventually::Initialized,
render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
resource::{Globals, IndexEntry, TrackedRenderPass},
tile_view_pattern::{TileInView, TileShape},
INDEX_FORMAT,
};
impl PhaseItem for TileInView {

3
maplibre/src/render/render_phase/draw.rs
View File

@ -1,4 +1,5 @@
use crate::{render::resource::TrackedRenderPass, RenderState};
use crate::render::resource::TrackedRenderPass;
use crate::render::RenderState;
/// A draw function which is used to draw a specific [`PhaseItem`].
///

2
maplibre/src/render/resource/surface.rs
View File

@ -3,10 +3,10 @@
use std::{mem::size_of, sync::Arc};
use crate::window::{MapWindow, WindowSize};
use crate::{
render::{eventually::HasChanged, resource::texture::TextureView, settings::RendererSettings},
window::HeadedMapWindow,
MapWindow, WindowSize,
};
pub struct BufferDimensions {

3
maplibre/src/render/stages/extract_stage.rs
View File

@ -1,8 +1,9 @@
//! Extracts data from the current state.
use crate::render::{RenderState, Renderer};
use crate::{
context::MapContext, coords::ViewRegion, render::eventually::Eventually::Initialized,
schedule::Stage, RenderState, Renderer,
schedule::Stage,
};
#[derive(Default)]

2
maplibre/src/render/stages/graph_runner_stage.rs
View File

@ -2,13 +2,13 @@
use log::error;
use crate::render::Renderer;
use crate::{
context::MapContext,
render::{
eventually::Eventually::Initialized, graph::RenderGraph, graph_runner::RenderGraphRunner,
},
schedule::Stage,
Renderer,
};
/// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.

3
maplibre/src/render/stages/phase_sort_stage.rs
View File

@ -1,6 +1,7 @@
//! Sorts items of the [RenderPhases](RenderPhase).
use crate::{context::MapContext, render::render_phase::RenderPhase, schedule::Stage, Renderer};
use crate::render::Renderer;
use crate::{context::MapContext, render::render_phase::RenderPhase, schedule::Stage};
#[derive(Default)]
pub struct PhaseSortStage;

2
maplibre/src/render/stages/queue_stage.rs
View File

@ -1,12 +1,12 @@
//! Queues [PhaseItems](crate::render::render_phase::PhaseItem) for rendering.
use crate::render::{RenderState, Renderer};
use crate::{
context::MapContext,
render::{
eventually::Eventually::Initialized, resource::IndexEntry, tile_view_pattern::TileInView,
},
schedule::Stage,
RenderState, Renderer,
};
#[derive(Default)]

2
maplibre/src/render/stages/resource_stage.rs
View File

@ -2,6 +2,7 @@
use std::mem::size_of;
use crate::render::Renderer;
use crate::{
context::MapContext,
render::{
@ -12,7 +13,6 @@ use crate::{
tile_view_pattern::{TileViewPattern, DEFAULT_TILE_VIEW_SIZE},
},
schedule::Stage,
Renderer,
};
#[derive(Default)]

3
maplibre/src/render/stages/upload_stage.rs
View File

@ -2,6 +2,8 @@
use std::iter;
use crate::render::{RenderState, Renderer};
use crate::style::Style;
use crate::{
context::MapContext,
coords::ViewRegion,
@ -12,7 +14,6 @@ use crate::{
shaders::{ShaderCamera, ShaderFeatureStyle, ShaderGlobals, ShaderLayerMetadata, Vec4f32},
},
schedule::Stage,
RenderState, Renderer, Style,
};
#[derive(Default)]

3
maplibre/src/stages/mod.rs
View File

@ -10,6 +10,8 @@ use std::{
use geozero::{mvt::tile, GeozeroDatasource};
use request_stage::RequestStage;
use crate::environment::Environment;
use crate::io::source_client::HttpClient;
use crate::{
coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
error::Error,
@ -30,7 +32,6 @@ use crate::{
schedule::Schedule,
stages::populate_tile_store_stage::PopulateTileStore,
tessellation::{IndexDataType, OverAlignedVertexBuffer},
Environment, HttpClient, Scheduler,
};
mod populate_tile_store_stage;

2
maplibre/src/stages/populate_tile_store_stage.rs
View File

@ -2,6 +2,7 @@
use std::{borrow::BorrowMut, cell::RefCell, ops::Deref, rc::Rc};
use crate::environment::Environment;
use crate::{
context::MapContext,
io::{
@ -10,7 +11,6 @@ use crate::{
transferables::{TessellatedLayer, TileTessellated, UnavailableLayer},
},
schedule::Stage,
Environment,
};
pub struct PopulateTileStore<E: Environment> {

3
maplibre/src/stages/request_stage.rs
View File

@ -12,6 +12,8 @@ use std::{
str::FromStr,
};
use crate::environment::Environment;
use crate::style::Style;
use crate::{
context::MapContext,
coords::{ViewRegion, WorldTileCoords, ZoomLevel},
@ -27,7 +29,6 @@ use crate::{
},
schedule::Stage,
stages::HeadedPipelineProcessor,
Environment, HttpClient, Scheduler, Style,
};
pub struct RequestStage<E: Environment> {

4
maplibre/src/window.rs
View File

@ -2,10 +2,10 @@
use std::{cell::RefCell, rc::Rc};
use crate::environment::Environment;
use crate::map_schedule::InteractiveMapSchedule;
use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
use crate::{Environment, HttpClient, InteractiveMapSchedule};
/// Window of a certain [`WindowSize`]. This can either be a proper window or a headless one.
pub trait MapWindow {
fn size(&self) -> WindowSize;

2
web/Cargo.toml
View File

@ -19,7 +19,7 @@ crate-type = ["cdylib", "rlib"]
[dependencies]
async-trait = "0.1.56"
maplibre = { path = "../maplibre", features = ["no-thread-safe-futures"] }
maplibre = { path = "../maplibre", default-features = false, features = [] }
maplibre-winit = { path = "../maplibre-winit", version = "0.0.1" }
log = "0.4.17"