Instrument another function

examples/desktop.rs

@@ -2,7 +2,7 @@ use mapr::{MapBuilder, ScheduleMethod, TokioScheduleMethod};
 
 #[cfg(feature = "enable-tracing")]
 fn enable_tracing() {
-    use tracing::{error, span};
+    
     use tracing_subscriber::layer::SubscriberExt;
     use tracing_subscriber::Registry;
 

src/io/mod.rs

@@ -8,7 +8,7 @@ use crate::tessellation::{IndexDataType, OverAlignedVertexBuffer};
 use crate::io::geometry_index::TileIndex;
 use std::collections::HashSet;
 use std::fmt;
-use std::fmt::{write, Formatter};
+
 use vector_tile::tile::Layer;
 
 mod geometry_index;

src/io/scheduler.rs

@@ -1,5 +1,5 @@
 use std::collections::{HashMap, HashSet};
-use std::fmt;
+
 
 use geozero::mvt::Tile;
 use geozero::GeozeroDatasource;

src/lib.rs

@@ -49,7 +49,6 @@ impl Map {
     pub fn run_sync_with_max_frames(self, max_frames: Option<u64>) {
         tokio::runtime::Builder::new_multi_thread()
             .worker_threads(2)
-            .threa
             .enable_io()
             .enable_time()
             .on_thread_start(|| {

src/render/buffer_pool.rs

@@ -286,9 +286,9 @@ impl<Q: Queue<B>, B, V: bytemuck::Pod, I: bytemuck::Pod, TM: bytemuck::Pod, FM:
 
 pub struct BackingBufferDescriptor<B> {
     /// The buffer which is used
-    pub buffer: B,
+    pub(crate) buffer: B,
     /// The size of buffer
-    inner_size: wgpu::BufferAddress,
+    pub(crate) inner_size: wgpu::BufferAddress,
 }
 
 impl<B> BackingBufferDescriptor<B> {

src/render/camera.rs

@@ -24,6 +24,7 @@ pub const FLIP_Y: cgmath::Matrix4<f64> = cgmath::Matrix4::new(
 pub struct ViewProjection(Matrix4<f64>);
 
 impl ViewProjection {
+    #[tracing::instrument(skip_all)]
     pub fn invert(&self) -> InvertedViewProjection {
         InvertedViewProjection(self.0.invert().expect("Unable to invert view projection"))
     }
@@ -106,6 +107,7 @@ impl Camera {
         )
     }
 
+    #[tracing::instrument(skip_all)]
     pub fn calc_view_proj(&self, perspective: &Perspective) -> ViewProjection {
         ViewProjection(FLIP_Y * perspective.calc_matrix() * self.calc_matrix())
     }

src/render/render_state.rs

@@ -1,18 +1,18 @@
 use std::collections::HashSet;
 use std::default::Default;
-use std::fmt::Formatter;
-use std::io::sink;
-use std::time::{Instant, SystemTime};
-use std::{cmp, fmt, iter};
 
-use cgmath::{Matrix4, Vector4};
+
+
+use std::{cmp, iter};
+
+
 use tracing;
 use wgpu::{Buffer, Limits, Queue};
 use winit::dpi::PhysicalSize;
 use winit::window::Window;
 
-use style_spec::layer::{LayerPaint, StyleLayer};
-use style_spec::{EncodedSrgb, Style};
+
+use style_spec::{Style};
 
 use crate::coords::{ViewRegion, TILE_SIZE};
 use crate::io::scheduler::IOScheduler;
@@ -26,7 +26,7 @@ use crate::render::options::{
     TILE_META_COUNT, TILE_VIEW_BUFFER_SIZE, VERTEX_BUFFER_SIZE,
 };
 use crate::render::tile_view_pattern::{TileInView, TileViewPattern};
-use crate::tessellation::{IndexDataType, OverAlignedVertexBuffer};
+use crate::tessellation::{IndexDataType};
 use crate::util::FPSMeter;
 
 use super::piplines::*;
@@ -375,7 +375,7 @@ impl RenderState {
             .collect();
 
         for coords in view_region.iter() {
-            if let Some(_) = coords.build_quad_key() {
+            if coords.build_quad_key().is_some() {
                 // TODO: Make tesselation depend on style?
                 scheduler.try_request_tile(&coords, &source_layers).unwrap();
             }
@@ -395,7 +395,7 @@ impl RenderState {
         self.tile_view_pattern
             .update_pattern(view_region, scheduler.get_tile_cache(), self.zoom);
         self.tile_view_pattern
-            .upload_pattern(&self.queue, &view_proj);
+            .upload_pattern(&self.queue, view_proj);
 
         /*let animated_one = 0.5
         * (1.0
@@ -467,11 +467,11 @@ impl RenderState {
     #[tracing::instrument(skip_all)]
     fn upload_tile_geometry(
         &mut self,
-        view_proj: &ViewProjection,
+        _view_proj: &ViewProjection,
         view_region: &ViewRegion,
         scheduler: &mut IOScheduler,
     ) {
-        let visible_z = self.visible_z();
+        let _visible_z = self.visible_z();
 
         // Upload all tessellated layers which are in view
         for world_coords in view_region.iter() {
@@ -502,7 +502,7 @@ impl RenderState {
                             .map(|color| color.into());
 
                         match result {
-                            LayerTessellateResult::UnavailableLayer { coords, .. } => {
+                            LayerTessellateResult::UnavailableLayer { coords: _, .. } => {
                                 /*self.buffer_pool.mark_layer_unavailable(*coords);*/
                             }
                             LayerTessellateResult::TessellatedLayer {
@@ -512,7 +512,7 @@ impl RenderState {
                                 buffer,
                                 ..
                             } => {
-                                let world_coords = coords;
+                                let _world_coords = coords;
 
                                 let feature_metadata = layer_data
                                     .features()
@@ -559,8 +559,8 @@ impl RenderState {
         drop(_guard);
 
         if let Some(view_region) = &view_region {
-            self.upload_tile_geometry(&view_proj, &view_region, scheduler);
-            self.update_metadata(scheduler, &view_region, &view_proj);
+            self.upload_tile_geometry(&view_proj, view_region, scheduler);
+            self.update_metadata(scheduler, view_region, &view_proj);
             self.request_tiles_in_view(view_region, scheduler);
         }
 

src/render/shaders/mod.rs

@@ -196,7 +196,7 @@ pub mod tile {
 pub mod tile_mask {
     use crate::platform::COLOR_TEXTURE_FORMAT;
     use crate::render::options::DEBUG_STENCIL_PATTERN;
-    use crate::render::shaders::{ShaderLayerMetadata, ShaderTileMetadata};
+    use crate::render::shaders::{ShaderTileMetadata};
     use wgpu::ColorWrites;
 
     use super::{FragmentShaderState, VertexShaderState};

src/render/tile_view_pattern.rs

@@ -1,11 +1,11 @@
-use crate::coords::{Quadkey, ViewRegion, WorldTileCoords};
+use crate::coords::{ViewRegion, WorldTileCoords};
 use crate::io::tile_cache::TileCache;
 use crate::render::buffer_pool::{BackingBufferDescriptor, Queue};
 use crate::render::camera::ViewProjection;
 use crate::render::shaders::ShaderTileMetadata;
 use cgmath::Matrix4;
-use lyon::geom::euclid::approxeq::ApproxEq;
-use std::collections::BTreeMap;
+
+
 use std::marker::PhantomData;
 use std::mem::size_of;
 use std::ops::Range;
@@ -64,7 +64,7 @@ impl<Q: Queue<B>, B> TileViewPattern<Q, B> {
         let mut index = 0;
 
         for coords in view_region.iter() {
-            if let None = coords.build_quad_key() {
+            if coords.build_quad_key().is_none() {
                 continue;
             }
 
@@ -140,7 +140,7 @@ impl<Q: Queue<B>, B> TileViewPattern<Q, B> {
         queue.write_buffer(
             &self.buffer.inner,
             0,
-            &bytemuck::cast_slice(&buffer.as_slice()),
+            bytemuck::cast_slice(buffer.as_slice()),
         );
     }