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

Add a lot of TODO notes

Browse Source
This commit is contained in:
Maximilian Ammann 2022-09-17 14:46:35 +02:00
parent 76bf7a6ecf
commit 12bb06a86e
31 changed files with 106 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
maplibre-demo/src/headed.rs
View File

@ -1,5 +1,5 @@
use maplibre::io::transferables::DefaultTransferables;
use maplibre::{
environment::DefaultTransferables,
io::apc::SchedulerAsyncProcedureCall,
platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
MapBuilder,

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

@ -23,7 +23,7 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
.with_apc(SchedulerAsyncProcedureCall::new(
client,
TokioScheduler::new(),
)) // TODO: avoid passing client and scheduler here
)) // FIXME (wasm-executor): avoid passing client and scheduler here
.with_scheduler(TokioScheduler::new())
.with_renderer_settings(RendererSettings {
texture_format: TextureFormat::Rgba8UnormSrgb,

2
maplibre-winit/Cargo.toml
View File

@ -21,5 +21,5 @@ wasm-bindgen-futures = "0.4.31"
maplibre = { path = "../maplibre", version = "0.0.2" }
winit = { version = "0.27.2", default-features = false }
cgmath = "0.18.0"
instant = { version = "0.1.12", features = ["wasm-bindgen"] } # FIXME: Untrusted dependency
instant = { version = "0.1.12", features = ["wasm-bindgen"] } # TODO: Untrusted dependency
log = "0.4.17"

1
maplibre-winit/src/input/query_handler.rs
View File

@ -71,6 +71,7 @@ impl UpdateState for QueryHandler {
&inverted_view_proj,
false,
) {
// TODO reenable
/*state
.scheduler()
.schedule(state.scheduler(), move |thread_local| async move {

3
maplibre-winit/src/winit/mod.rs
View File

@ -1,8 +1,9 @@
use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
use instant::Instant;
use maplibre::io::transferables::DefaultTransferables;
use maplibre::{
environment::{DefaultTransferables, Environment},
environment::Environment,
error::Error,
io::{
apc::{AsyncProcedureCall, Message},

2
maplibre/Cargo.toml
View File

@ -33,7 +33,7 @@ reqwest = { version = "0.11.11", default-features = false, features = ["rustls-t
[dependencies]
async-trait = "0.1.57"
instant = { version = "0.1.12", features = ["wasm-bindgen"] } # FIXME: Untrusted dependency
instant = { version = "0.1.12", features = ["wasm-bindgen"] } # TODO: Untrusted dependency
# Tracing
tracing = "0.1.36"

4
maplibre/src/coords.rs
View File

@ -101,7 +101,7 @@ impl std::ops::Add<u8> for ZoomLevel {
type Output = ZoomLevel;
fn add(self, rhs: u8) -> Self::Output {
let zoom_level = self.0.checked_add(rhs).unwrap();
let zoom_level = self.0.checked_add(rhs).expect("zoom level overflowed");
ZoomLevel(zoom_level)
}
}
@ -110,7 +110,7 @@ impl std::ops::Sub<u8> for ZoomLevel {
type Output = ZoomLevel;
fn sub(self, rhs: u8) -> Self::Output {
let zoom_level = self.0.checked_sub(rhs).unwrap();
let zoom_level = self.0.checked_sub(rhs).expect("zoom level underflowed");
ZoomLevel(zoom_level)
}
}

9
maplibre/src/environment.rs
View File

@ -17,12 +17,3 @@ pub trait Environment: 'static {
type Transferables: Transferables;
}
#[derive(Copy, Clone)]
pub struct DefaultTransferables;
impl Transferables for DefaultTransferables {
type TileTessellated = DefaultTileTessellated;
type UnavailableLayer = DefaultUnavailableLayer;
type TessellatedLayer = DefaultTessellatedLayer;
}

14
maplibre/src/headless.rs
View File

@ -12,10 +12,10 @@ use std::{
use tokio::{runtime::Handle, task};
use wgpu::{BufferAsyncError, BufferSlice};
use crate::io::transferables::DefaultTransferables;
use crate::{
context::{MapContext, ViewState},
coords::{LatLon, ViewRegion, WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
environment::DefaultTransferables,
error::Error,
headless::utils::HeadlessPipelineProcessor,
io::{
@ -126,12 +126,12 @@ impl<E: Environment> HeadlessMapSchedule<E> {
let tile_repository = TileRepository::new();
let mut schedule = Schedule::default();
let mut graph = create_default_render_graph().unwrap();
let draw_graph = graph.get_sub_graph_mut(draw_graph::NAME).unwrap();
let mut graph = create_default_render_graph().unwrap(); // TODO: remove unwrap
let draw_graph = graph.get_sub_graph_mut(draw_graph::NAME).unwrap(); // TODO: remove unwrap
draw_graph.add_node(draw_graph::node::COPY, CopySurfaceBufferNode::default());
draw_graph
.add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
.unwrap();
.unwrap(); // TODO: remove unwrap
register_default_render_stages(graph, &mut schedule);
@ -185,7 +185,7 @@ impl<E: Environment> HeadlessMapSchedule<E> {
let data = http_source_client
.fetch(&coords)
.await
.unwrap()
.unwrap() // TODO: remove unwrap
.into_boxed_slice();
let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
@ -200,7 +200,7 @@ impl<E: Environment> HeadlessMapSchedule<E> {
let mut processor = pipeline_context
.take_processor::<HeadlessPipelineProcessor>()
.unwrap();
.unwrap(); // TODO: remove unwrap
if let Eventually::Initialized(pool) = self.map_context.renderer.state.buffer_pool_mut() {
pool.clear();
@ -260,7 +260,7 @@ impl Node for CopySurfaceBufferNode {
std::num::NonZeroU32::new(
buffered_texture.buffer_dimensions.padded_bytes_per_row as u32,
)
.unwrap(),
.unwrap(), // TODO: remove unwrap
),
rows_per_image: None,
},

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

@ -10,9 +10,9 @@ use std::{
use serde::{Deserialize, Serialize};
use crate::io::transferables::DefaultTransferables;
use crate::{
coords::WorldTileCoords,
environment::DefaultTransferables,
io::{
source_client::{HttpSourceClient, SourceClient},
transferables::Transferables,
@ -57,16 +57,15 @@ pub trait AsyncProcedureCall<T: Transferables, HC: HttpClient>: 'static {
fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>);
}
// FIXME: Make this generic using the Schedule
#[derive(Clone)]
pub struct TokioContext<T: Transferables, HC: HttpClient> {
pub struct SchedulerContext<T: Transferables, HC: HttpClient> {
sender: Sender<Message<T>>,
source_client: SourceClient<HC>,
}
impl<T: Transferables, HC: HttpClient> Context<T, HC> for TokioContext<T, HC> {
impl<T: Transferables, HC: HttpClient> Context<T, HC> for SchedulerContext<T, HC> {
fn send(&self, data: Message<T>) {
self.sender.send(data).unwrap();
self.sender.send(data).unwrap(); // FIXME (wasm-executor): Remove unwrap
}
fn source_client(&self) -> &SourceClient<HC> {
@ -96,7 +95,7 @@ impl<HC: HttpClient, S: Scheduler> SchedulerAsyncProcedureCall<HC, S> {
impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<DefaultTransferables, HC>
for SchedulerAsyncProcedureCall<HC, S>
{
type Context = TokioContext<DefaultTransferables, HC>;
type Context = SchedulerContext<DefaultTransferables, HC>;
fn receive(&mut self) -> Option<Message<DefaultTransferables>> {
let transferred = self.channel.1.try_recv().ok()?;
@ -105,13 +104,13 @@ impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<DefaultTransferables, HC>
fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
let sender = self.channel.0.clone();
let client = self.http_client.clone(); // FIXME: do not clone each time
let client = self.http_client.clone(); // FIXME (wasm-executor): do not clone each time
self.scheduler
.schedule(move || async move {
(procedure)(
input,
TokioContext {
SchedulerContext {
sender,
source_client: SourceClient::Http(HttpSourceClient::new(client)),
},

2
maplibre/src/io/static_tile_fetcher.rs
View File

@ -46,7 +46,7 @@ impl StaticTileFetcher {
.ok_or_else(|| {
Error::Network("Failed to load tile from within the binary".to_string())
})?;
Ok(Vec::from(tile.contents())) // TODO: Unnecessary copy
Ok(Vec::from(tile.contents()))
}
}

11
maplibre/src/io/transferables.rs
View File

@ -66,7 +66,7 @@ pub struct DefaultTessellatedLayer {
pub buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
/// Holds for each feature the count of indices.
pub feature_indices: Vec<u32>,
pub layer_data: Layer, // FIXME: Introduce a better structure for this
pub layer_data: Layer, // FIXME (wasm-executor): Introduce a better structure for this
}
impl TessellatedLayer for DefaultTessellatedLayer {
@ -99,3 +99,12 @@ pub trait Transferables: 'static {
type UnavailableLayer: UnavailableLayer;
type TessellatedLayer: TessellatedLayer;
}
#[derive(Copy, Clone)]
pub struct DefaultTransferables;
impl Transferables for DefaultTransferables {
type TileTessellated = DefaultTileTessellated;
type UnavailableLayer = DefaultUnavailableLayer;
type TessellatedLayer = DefaultTessellatedLayer;
}

12
maplibre/src/lib.rs
View File

@ -67,7 +67,7 @@ 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: Avoid RefCell, change ownership model!
// FIXME (wasm-executor): Avoid RefCell, change ownership model!
map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
}
@ -99,7 +99,7 @@ where
self.window
.borrow_mut()
.take()
.unwrap()
.unwrap() // FIXME (wasm-executor): Remove unwrap
.run(self.map_schedule.clone(), max_frames);
}
@ -250,13 +250,13 @@ impl<E: Environment> MapBuilder<E> {
/// Builds the UninitializedMap with the given configuration.
pub fn build(self) -> UninitializedMap<E> {
UninitializedMap {
scheduler: self.scheduler.unwrap(),
apc: self.apc.unwrap(),
http_client: self.http_client.unwrap(),
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(),
map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
}
}
}

8
maplibre/src/map_schedule.rs
View File

@ -21,7 +21,7 @@ use crate::{
pub struct InteractiveMapSchedule<E: Environment> {
map_window_config: E::MapWindowConfig,
// FIXME: avoid RefCell, change ownership model
// FIXME (wasm-executor): avoid RefCell, change ownership model
pub apc: Rc<RefCell<E::AsyncProcedureCall>>,
map_context: EventuallyMapContext,
@ -54,13 +54,13 @@ impl<E: Environment> InteractiveMapSchedule<E> {
let tile_repository = TileRepository::new();
let mut schedule = Schedule::default();
let apc = Rc::new(RefCell::new(apc)); // TODO: remove refcell, rc
let apc = Rc::new(RefCell::new(apc));
let http_source_client: HttpSourceClient<E::HttpClient> =
HttpSourceClient::new(http_client);
register_stages::<E>(&mut schedule, http_source_client, apc.clone());
let graph = create_default_render_graph().unwrap();
let graph = create_default_render_graph().unwrap(); // TODO: Remove unwrap
register_default_render_stages(graph, &mut schedule);
Self {
@ -157,7 +157,7 @@ where
let renderer =
Renderer::initialize(&window, wgpu_settings.clone(), renderer_settings.clone())
.await
.unwrap();
.unwrap(); // TODO: Remove unwrap
self.map_context.make_full(renderer);
true
}

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

@ -191,7 +191,7 @@ impl<Q: Queue<B>, B, V: Pod, I: Pod, TM: Pod, FM: Pod> BufferPool<Q, B, V, I, TM
self.index.get_layers(coords).map(|layers| {
layers
.iter()
.map(|entry| entry.style_layer.source_layer.as_ref().unwrap().as_str())
.map(|entry| entry.style_layer.source_layer.as_ref().unwrap().as_str()) // TODO: Remove unwrap
.collect()
})
}

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

@ -84,7 +84,7 @@ impl BufferedTextureHead {
let padded_buffer = buffer_slice.get_mapped_range();
let mut png_encoder = png::Encoder::new(
File::create(png_output_path).unwrap(),
File::create(png_output_path).unwrap(), // TODO: Remove unwrap
self.buffer_dimensions.width as u32,
self.buffer_dimensions.height as u32,
);
@ -92,17 +92,17 @@ impl BufferedTextureHead {
png_encoder.set_color(png::ColorType::Rgba);
let mut png_writer = png_encoder
.write_header()
.unwrap()
.unwrap() // TODO: Remove unwrap
.into_stream_writer_with_size(self.buffer_dimensions.unpadded_bytes_per_row)
.unwrap();
.unwrap(); // TODO: Remove unwrap
// from the padded_buffer we write just the unpadded bytes into the image
for chunk in padded_buffer.chunks(self.buffer_dimensions.padded_bytes_per_row) {
png_writer
.write_all(&chunk[..self.buffer_dimensions.unpadded_bytes_per_row])
.unwrap();
.unwrap(); // TODO: Remove unwrap
}
png_writer.finish().unwrap();
png_writer.finish().unwrap(); // TODO: Remove unwrap
// With the current interface, we have to make sure all mapped views are
// dropped before we unmap the buffer.

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

@ -44,7 +44,7 @@ impl Stage for UploadStage {
.position
.to_homogeneous()
.cast::<f32>()
.unwrap()
.unwrap() // TODO: Remove unwrap
.into(),
))]),
);
@ -168,7 +168,7 @@ impl UploadStage {
})
{
for style_layer in &style.layers {
let source_layer = style_layer.source_layer.as_ref().unwrap();
let source_layer = style_layer.source_layer.as_ref().unwrap(); // TODO: Remove unwrap
if let Some(message) = available_layers
.iter()

4
maplibre/src/render/tile_view_pattern.rs
View File

@ -166,8 +166,8 @@ impl<Q: Queue<B>, B> TileViewPattern<Q, B> {
let raw_buffer = bytemuck::cast_slice(buffer.as_slice());
if raw_buffer.len() as wgpu::BufferAddress > self.buffer.inner_size {
/* FIXME: We need to avoid this case by either choosing a proper size
(DEFAULT_TILE_VIEW_SIZE), or resizing the buffer */
/* TODO: We need to avoid this case by either choosing a proper size
TODO: (DEFAULT_TILE_VIEW_SIZE), or resizing the buffer */
panic!("Buffer is too small to store the tile pattern!");
}
queue.write_buffer(&self.buffer.inner, 0, raw_buffer);

2
maplibre/src/schedule.rs
View File

@ -250,7 +250,7 @@ impl Schedule {
for label in &self.stage_order {
#[cfg(feature = "trace")]
let _stage_span = tracing::info_span!("stage", name = ?label).entered();
let stage = self.stages.get_mut(label).unwrap();
let stage = self.stages.get_mut(label).unwrap(); // TODO: Remove unwrap
stage.run(context);
}
}

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

@ -10,9 +10,9 @@ use std::{
use geozero::{mvt::tile, GeozeroDatasource};
use request_stage::RequestStage;
use crate::io::transferables::DefaultTransferables;
use crate::{
coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
environment::DefaultTransferables,
error::Error,
io::{
apc::{AsyncProcedureCall, Context, Message},
@ -92,67 +92,15 @@ impl<'c, T: Transferables, HC: HttpClient, C: Context<T, HC>> PipelineProcessor
coords: &WorldTileCoords,
geometries: Vec<IndexedGeometry<f64>>,
) {
// TODO: Readd
// FIXME (wasm-executor): Readd
/* if let Ok(mut geometry_index) = self.state.geometry_index.lock() {
geometry_index.index_tile(coords, TileIndex::Linear { list: geometries })
}*/
}
}
// FIXME: clean this up
///// Stores and provides access to the thread safe data shared between the schedulers.
//[derive(Clone)]
//pub struct SharedThreadState {
/* pub tile_request_state: Arc<Mutex<TileRequestState>>,
pub message_sender: mpsc::Sender<TessellateMessage>,*/
// TODO: Readd
//pub geometry_index: Arc<Mutex<GeometryIndex>>,
//}
//impl SharedThreadState {
/* fn get_tile_request(&self, request_id: TileRequestID) -> Option<TileRequest> {
self.tile_request_state
.lock()
.ok()
.and_then(|tile_request_state| tile_request_state.get_tile_request(request_id).cloned())
}
#[tracing::instrument(skip_all)]
pub fn process_tile(&self, request_id: TileRequestID, data: Box<[u8]>) -> Result<(), Error> {
if let Some(tile_request) = self.get_tile_request(request_id) {
let mut pipeline_context = PipelineContext::new(HeadedPipelineProcessor {
state: self.clone(),
});
let pipeline = build_vector_tile_pipeline();
pipeline.process((tile_request, request_id, data), &mut pipeline_context);
}
Ok(())
}
pub fn tile_unavailable(
&self,
coords: &WorldTileCoords,
request_id: TileRequestID,
) -> Result<(), Error> {
if let Some(tile_request) = self.get_tile_request(request_id) {
for to_load in &tile_request.layers {
tracing::warn!("layer {} at {} unavailable", to_load, coords);
self.message_sender.send(TessellateMessage::Layer(
LayerTessellateMessage::UnavailableLayer {
coords: tile_request.coords,
layer_name: to_load.to_string(),
},
))?;
}
}
Ok(())
}*/
// TODO: Readd
/* #[tracing::instrument(skip_all)]
pub fn query_point(
// FIXME (wasm-executor): Readd
/*pub fn query_point(
&self,
world_coords: &WorldCoords,
z: ZoomLevel,

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

@ -12,6 +12,8 @@ use std::{
str::FromStr,
};
use crate::io::apc::Message;
use crate::io::transferables::{Transferables, UnavailableLayer};
use crate::{
context::MapContext,
coords::{ViewRegion, WorldTileCoords, ZoomLevel},
@ -79,7 +81,7 @@ pub fn schedule<E: Environment, C: Context<E::Transferables, E::HttpClient>>(
Input::TileRequest(input) => Some(input),
_ => None,
}
.unwrap();
.unwrap(); // FIXME (wasm-executor): Remove unwrap
Box::pin(async move {
let coords = input.coords;
@ -99,7 +101,15 @@ pub fn schedule<E: Environment, C: Context<E::Transferables, E::HttpClient>>(
}
Err(e) => {
log::error!("{:?}", &e);
//state.tile_unavailable(&coords, request_id).unwrap()
for to_load in &input.layers {
tracing::warn!("layer {} at {} unavailable", to_load, coords);
context.send(Message::UnavailableLayer(
<E::Transferables as Transferables>::UnavailableLayer::new(
input.coords,
to_load.to_string(),
),
));
}
}
}
})
@ -124,7 +134,7 @@ impl<E: Environment> RequestStage<E> {
if coords.build_quad_key().is_some() {
// TODO: Make tesselation depend on style?
self.request_tile(tile_repository, &coords, &source_layers)
.unwrap();
.unwrap(); // TODO: Remove unwrap
}
}
}

2
maplibre/src/tessellation/mod.rs
View File

@ -62,7 +62,7 @@ impl<V, I> OverAlignedVertexBuffer<V, I> {
V: Copy,
I: Copy,
{
// FIXME, make this fn not needed
// FIXME (wasm-executor), make this fn not needed
let mut buffers = VertexBuffers::with_capacity(0, 0);
buffers.vertices = Vec::from(vertices);
buffers.indices = Vec::from(indices);

4
maplibre/src/tessellation/zero_tessellator.rs
View File

@ -64,7 +64,7 @@ impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> ZeroTesse
&StrokeOptions::tolerance(DEFAULT_TOLERANCE),
&mut BuffersBuilder::new(&mut self.buffer, VertexConstructor {}),
)
.unwrap();
.unwrap(); // TODO: Remove unwrap
}
fn end(&mut self, close: bool) {
@ -83,7 +83,7 @@ impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> ZeroTesse
&FillOptions::tolerance(DEFAULT_TOLERANCE).with_fill_rule(FillRule::NonZero),
&mut BuffersBuilder::new(&mut self.buffer, VertexConstructor {}),
)
.unwrap();
.unwrap(); // TODO: Remove unwrap
}
}

2
maplibre/src/window.rs
View File

@ -30,7 +30,7 @@ pub trait MapWindowConfig: 'static {
/// The event loop is responsible for processing events and propagating them to the map renderer.
/// Only non-headless windows use an [`EventLoop`].
pub trait EventLoop<E: Environment> {
// FIXME: Avoid Rc, change ownership model
// FIXME (wasm-executor): Avoid Rc, change ownership model
fn run(self, map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>, max_frames: Option<u64>);
}

8
web/Cargo.toml
View File

@ -37,11 +37,11 @@ js-sys = "0.3.58"
wasm-bindgen = "0.2.81"
wasm-bindgen-futures = "0.4.31"
console_log = { version = "0.2.0", features = ["color"] }
tracing-wasm = { version = "0.2.1", optional = true } # FIXME: Low quality dependency
serde = "1.0.144" # FIXME: Remove
tracing-wasm = { version = "0.2.1", optional = true } # TODO: Low quality dependency
# For passing Inputs in AsyncProcedureCalls
serde_json = "1.0.85"
bytemuck = "1.12.1"
bytemuck_derive = "1.2.1"
bytemuck = "1.12.1" # FIXME (wasm-executor): Remove
bytemuck_derive = "1.2.1" # FIXME (wasm-executor): Remove
[dev-dependencies]
wasm-bindgen-test = "0.3.31"

4
web/src/error.rs
View File

@ -9,7 +9,7 @@ pub struct WebError(pub String);
impl From<JsValue> for WebError {
fn from(maybe_error: JsValue) -> Self {
assert!(maybe_error.is_instance_of::<JSError>());
let error: JSError = maybe_error.dyn_into().unwrap();
WebError(error.message().as_string().unwrap())
let error: JSError = maybe_error.dyn_into().unwrap(); // TODO: Remove unwrap
WebError(error.message().as_string().unwrap()) // TODO: remove unwrap
}
}

2
web/src/lib.rs
View File

@ -53,7 +53,7 @@ pub type MapType = Map<
WinitEnvironment<
platform::sync::pool_scheduler::WebWorkerPoolScheduler,
WHATWGFetchHttpClient,
maplibre::environment::DefaultTransferables,
maplibre::io::transferables::DefaultTransferables,
maplibre::io::apc::SchedulerAsyncProcedureCall<
WHATWGFetchHttpClient,
platform::sync::pool_scheduler::WebWorkerPoolScheduler,

6
web/src/platform/http_client.rs
View File

@ -23,12 +23,12 @@ impl WHATWGFetchHttpClient {
// Get the global scope
let global = js_sys::global();
assert!(global.is_instance_of::<WorkerGlobalScope>());
let scope = global.dyn_into::<WorkerGlobalScope>().unwrap();
let scope = global.dyn_into::<WorkerGlobalScope>().unwrap(); // TODO: remove unwrap
// Call fetch on global scope
let maybe_response = JsFuture::from(scope.fetch_with_request(&request)).await?;
assert!(maybe_response.is_instance_of::<Response>());
let response: Response = maybe_response.dyn_into().unwrap();
let response: Response = maybe_response.dyn_into().unwrap(); // TODO: remove unwrap
// Get ArrayBuffer
let maybe_array_buffer = JsFuture::from(response.array_buffer()?).await?;
@ -39,7 +39,7 @@ impl WHATWGFetchHttpClient {
let maybe_array_buffer = Self::fetch_array_buffer(url).await?;
assert!(maybe_array_buffer.is_instance_of::<ArrayBuffer>());
let array_buffer: ArrayBuffer = maybe_array_buffer.dyn_into().unwrap();
let array_buffer: ArrayBuffer = maybe_array_buffer.dyn_into().unwrap(); // TODO: remove unwrap
// Copy data to Vec<u8>
let buffer: Uint8Array = Uint8Array::new(&array_buffer);

8
web/src/platform/sync/pool_scheduler.rs
View File

@ -19,12 +19,12 @@ impl WebWorkerPoolScheduler {
Box::new(move || {
new_worker
.call0(&JsValue::undefined())
.unwrap()
.unwrap() // FIXME (wasm-executor): Remove unwrap
.dyn_into::<Worker>()
.unwrap()
.unwrap() // FIXME (wasm-executor): remove unwrap
}),
)
.unwrap(),
.unwrap(), // FIXME (wasm-executor): Remove unwrap
}
}
}
@ -44,7 +44,7 @@ impl Scheduler for WebWorkerPoolScheduler {
Ok(JsValue::undefined())
})
})
.unwrap();
.unwrap(); // FIXME (wasm-executor): remove unwrap
Ok(())
}
}

26
web/src/platform/unsync/apc.rs
View File

@ -24,7 +24,6 @@ use maplibre::{
transferables::Transferables,
},
};
use serde::Serialize;
use wasm_bindgen::{prelude::*, JsCast, JsValue};
use web_sys::{DedicatedWorkerGlobalScope, Worker};
@ -56,11 +55,11 @@ impl Context<UsedTransferables, UsedHttpClient> for PassingContext {
serialized_array.set(&Uint8Array::view(serialized), 0);
}
let global = js_sys::global().unchecked_into::<DedicatedWorkerGlobalScope>();
let global = js_sys::global().unchecked_into::<DedicatedWorkerGlobalScope>(); // FIXME (wasm-executor): Remove unchecked
let array = js_sys::Array::new();
array.push(&JsValue::from(tag));
array.push(&serialized_array_buffer);
global.post_message(&array).unwrap();
global.post_message(&array).unwrap(); // FIXME (wasm-executor) Remove unwrap
}
fn source_client(&self) -> &SourceClient<UsedHttpClient> {
@ -80,9 +79,9 @@ impl PassingAsyncProcedureCall {
let create_new_worker = Box::new(move || {
new_worker
.call0(&JsValue::undefined())
.unwrap()
.unwrap() // FIXME (wasm-executor): Remove unwrap
.dyn_into::<Worker>()
.unwrap()
.unwrap() // FIXME (wasm-executor): Remove unwrap
});
let workers = (0..initial_workers)
@ -91,7 +90,7 @@ impl PassingAsyncProcedureCall {
let array = js_sys::Array::new();
array.push(&wasm_bindgen::module());
worker.post_message(&array).unwrap();
worker.post_message(&array).unwrap(); // FIXME (wasm-executor): Remove unwrap
worker
})
.collect::<Vec<_>>();
@ -112,14 +111,14 @@ impl AsyncProcedureCall<UsedTransferables, UsedHttpClient> for PassingAsyncProce
}
fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
let procedure_ptr = procedure as *mut AsyncProcedure<Self::Context> as u32; // TODO: is u32 fine?
let input = serde_json::to_string(&input).unwrap();
let procedure_ptr = procedure as *mut AsyncProcedure<Self::Context> as u32; // FIXME (wasm-executor): is u32 fine, define an overflow safe function?
let input = serde_json::to_string(&input).unwrap(); // FIXME (wasm-executor): Remove unwrap
let array = js_sys::Array::new();
array.push(&JsValue::from(procedure_ptr));
array.push(&JsValue::from(input));
self.workers[0].post_message(&array).unwrap();
self.workers[0].post_message(&array).unwrap(); // FIXME (wasm-executor): Remove unwrap
}
}
@ -130,7 +129,7 @@ pub async fn unsync_worker_entry(procedure_ptr: u32, input: String) -> Result<()
let procedure: AsyncProcedure<UsedContext> = unsafe { std::mem::transmute(procedure_ptr) };
let input = serde_json::from_str::<Input>(&input).unwrap();
let input = serde_json::from_str::<Input>(&input).unwrap(); // FIXME (wasm-executor): Remove unwrap
let context = PassingContext {
source_client: SourceClient::Http(HttpSourceClient::new(WHATWGFetchHttpClient::new())),
@ -148,8 +147,10 @@ pub fn unsync_main_entry(
tag: u32,
data: Uint8Array,
) -> Result<(), JsValue> {
// FIXME (wasm-executor): Can we make this call safe? check if it was cloned before?
let mut map = unsafe { Rc::from_raw(map_ptr) };
// FIXME (wasm-executor): remove tag somehow
let transferred = match tag {
3 => Some(Message::<UsedTransferables>::TessellatedLayer(
LinearTessellatedLayer {
@ -174,9 +175,8 @@ pub fn unsync_main_entry(
)),
_ => None,
}
.unwrap();
.unwrap(); // FIXME (wasm-executor): Remove unwrap
// FIXME: avoid this borrow mess
map.deref()
.borrow()
.map_schedule()
@ -188,7 +188,7 @@ pub fn unsync_main_entry(
.received
.push(transferred);
mem::forget(map);
mem::forget(map); // FIXME (wasm-executor): Enforce this somehow
Ok(())
}

6
web/src/platform/unsync/transferables.rs
View File

@ -11,7 +11,7 @@ use maplibre::{
tile::Layer,
};
// FIXME: properly do this!, fix this whole file
// FIXME (wasm-executor): properly do this!, fix this whole file
#[derive(Copy, Clone, Debug)]
#[repr(transparent)]
pub struct WrapperWorldTileCoords(WorldTileCoords);
@ -71,7 +71,7 @@ impl UnavailableLayer for LinearUnavailableLayer {
fn to_stored_layer(self) -> StoredLayer {
StoredLayer::UnavailableLayer {
coords: WrapperWorldTileCoords::peel(self.coords),
layer_name: String::from_utf8(Vec::from(self.layer_name)).unwrap(),
layer_name: String::from_utf8(Vec::from(self.layer_name)).unwrap(), // FIXME (wasm-executor): Remove unwrap
}
}
}
@ -136,7 +136,7 @@ impl TessellatedLayer for LinearTessellatedLayer {
layer_name: String::from_utf8(Vec::from(
&self.data.layer_name[..self.data.layer_name_len],
))
.unwrap(),
.unwrap(), // FIXME (wasm-executor): Remove unwrap
buffer: OverAlignedVertexBuffer::from_slices(
&self.data.vertices.0[..self.data.vertices_len],
&self.data.indices.0[..self.data.indices_len],