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 headless rendering

Browse Source
This commit is contained in:
Maximilian Ammann 2022-09-25 19:12:20 +02:00
parent c663416d05
commit b863cef589
2 changed files with 28 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
maplibre-demo/src/headless.rs
View File

@ -35,7 +35,15 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
.await
.expect("Failed to initialize renderer");
let mut map = HeadlessMap::new(Style::default(), renderer, kernel).unwrap();
let style = Style::default();
let requested_layers = style
.layers
.iter()
.map(|layer| layer.source_layer.as_ref().unwrap().clone())
.collect::<Vec<_>>();
let mut map = HeadlessMap::new(style, renderer, kernel).unwrap();
let tile_limits = google_mercator().tile_limits(
extent_wgs84_to_merc(&Extent {
@ -51,10 +59,16 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
let coords = WorldTileCoords::from((x as i32, y as i32, z.into()));
println!("Rendering {}", &coords);
let tile = map
.fetch_tile(coords, &["water"])
.fetch_tile(
coords,
&requested_layers
.iter()
.map(|layer| layer.as_str())
.collect::<Vec<_>>(),
)
.await
.expect("Failed to fetch and process!");
.expect("Failed to fetch and process");
map.render_tile(tile);
map.render_tile(tile).expect("Rendering failed");
}
}

17
maplibre/src/headless/map.rs
View File

@ -46,11 +46,9 @@ impl HeadlessMap {
window_size,
WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
Zoom::default(),
cgmath::Deg(110.0),
cgmath::Deg(0.0),
);
let mut schedule = Schedule::default();
let mut graph = create_default_render_graph()?;
let draw_graph = graph
.get_sub_graph_mut(draw_graph::NAME)
@ -60,8 +58,8 @@ impl HeadlessMap {
.add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
.unwrap(); // TODO: remove unwrap
let mut schedule = Schedule::default();
register_default_render_stages(graph, &mut schedule);
schedule.add_stage(
RenderStageLabel::Cleanup,
WriteSurfaceBufferStage::default(),
@ -78,13 +76,17 @@ impl HeadlessMap {
})
}
pub async fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
pub fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
let context = &mut self.map_context;
if let Eventually::Initialized(pool) = context.renderer.state.buffer_pool_mut() {
pool.clear();
} else {
// TODO return error
}
context.world.tile_repository.clear();
context.world.tile_repository.put_tile(tile);
self.schedule.run(&mut self.map_context);
@ -103,10 +105,11 @@ impl HeadlessMap {
let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
let pipeline = build_vector_tile_pipeline();
let target_coords = WorldTileCoords::default(); // load to 0,0,0
pipeline.process(
(
TileRequest {
coords: WorldTileCoords::default(),
coords: target_coords,
layers: source_layers
.iter()
.map(|layer| layer.to_string())
@ -121,7 +124,7 @@ impl HeadlessMap {
.take_processor::<HeadlessPipelineProcessor>()
.expect("Unable to get processor");
Ok(StoredTile::success(coords, processor.layers))
Ok(StoredTile::success(target_coords, processor.layers))
}
}