Remove redundant viewport parameter from draw fns

src/map_view_gl.rs

             self.mercator_tile_layer.prepare_draw(cx, &self.tile_atlas);
         }
 
-        //TODO remove viewport_size parameter
         self.mercator_tile_layer.draw(
             cx,
             &self.map_view,
             source,
             &mut self.tile_cache,
             &mut self.tile_atlas,
-            self.viewport_size,
             snap_to_pixel
         )
     }
 
-    fn draw_marker(&mut self, cx: &mut Context, snap_to_pixel: bool) {
+    fn draw_mercator_marker(&mut self, cx: &mut Context, snap_to_pixel: bool) {
         if self.last_draw_type != DrawType::Markers {
             self.last_draw_type = DrawType::Markers;
             self.marker_layer.prepare_draw(cx);
         }
 
-        //TODO remove viewport_size parameter
-        self.marker_layer.draw(
+        self.marker_layer.draw_mercator(
             cx,
             &self.map_view,
-            self.viewport_size,
             self.dpi_factor,
             snap_to_pixel,
         );
             Projection::Mercator => {
                 let ret = self.draw_mercator_tiles(cx, source, snap_to_pixel);
                 if !self.marker_layer.is_empty() {
-                    self.draw_marker(cx, snap_to_pixel);
+                    self.draw_mercator_marker(cx, snap_to_pixel);
                 }
                 ret
             },

src/marker_layer.rs

         self.program.set_vertex_attribs(cx, &self.buffer);
     }
 
-    pub fn draw(
+    pub fn draw_mercator(
         &mut self,
         cx: &mut Context,
         map_view: &MapView,
-        viewport_size: (u32, u32),
         dpi_factor: f64,
         snap_to_pixel: bool
     ) {
         let marker_size = vec2::<f64>(40.0, 50.0) * dpi_factor;
         let marker_offset = vec2::<f64>(-20.0, -50.0) * dpi_factor;
 
-        let scale_x = 2.0 / viewport_size.0 as f32;
-        let scale_y = -2.0 / viewport_size.1 as f32;
+        let scale_x = 2.0 / map_view.width as f32;
+        let scale_y = -2.0 / map_view.height as f32;
 
         let tex_mat: Matrix3<f32> = Matrix3::from_cols(
             vec3(marker_size.x as f32, 0.0, 0.0),
         let visible_rect = ScreenRect {
             x: -(marker_offset.x + marker_size.x),
             y: -(marker_offset.y + marker_size.y),
-            width: f64::from(viewport_size.0) + marker_size.x,
-            height: f64::from(viewport_size.1) + marker_size.y,
+            width: map_view.width + marker_size.x,
+            height: map_view.height + marker_size.y,
         };
 
         for map_pos in &self.positions {

src/mercator_tile_layer.rs

         source: &TileSource,
         cache: &mut TileCache,
         atlas: &mut TileAtlas,
-        viewport_size: (u32, u32),
         snap_to_pixel: bool
     ) -> Result<usize, usize> {
         cache.set_view_location(View {
             max_tiles_to_use = max_tiles_to_use.saturating_sub(used_tiles);
 
             let mut vertex_data: Vec<f32> = Vec::with_capacity(textured_visible_tiles.len() * (6 * 8));
-            let scale_x = 2.0 / f64::from(viewport_size.0);
-            let scale_y = -2.0 / f64::from(viewport_size.1);
+            let scale_x = 2.0 / map_view.width;
+            let scale_y = -2.0 / map_view.height;
             for tvt in &textured_visible_tiles {
                 let minmax = [
                     tvt.tex_minmax.x1 as f32,