Rename tile_layer -> mercator_tile_layer

and TileLayer -> MercatorTileLayer

src/main.rs

 #[macro_use]
 pub mod context;
 pub mod coord;
-pub mod ortho_tile_layer;
 pub mod map_view;
 pub mod map_view_gl;
 pub mod marker_layer;
+pub mod mercator_tile_layer;
 pub mod mercator_view;
+pub mod ortho_tile_layer;
 pub mod orthografic_view;
 pub mod program;
 pub mod search;
 pub mod tile;
 pub mod tile_atlas;
 pub mod tile_cache;
-pub mod tile_layer;
 pub mod tile_loader;
 pub mod tile_source;
 pub mod url_template;

src/map_view_gl.rs

 use texture::{Texture, TextureFormat};
 use tile_atlas::TileAtlas;
 use tile_cache::TileCache;
-use tile_layer::TileLayer;
+use mercator_tile_layer::MercatorTileLayer;
 use tile_source::TileSource;
 
 
     dpi_factor: f64,
     tile_cache: TileCache,
     tile_atlas: TileAtlas,
-    tile_layer: TileLayer,
+    mercator_tile_layer: MercatorTileLayer,
     marker_layer: MarkerLayer,
     ortho_tile_layer: OrthoTileLayer,
     projection: Projection,
     {
         let tile_size = 256;
 
-        let mut map_view = MercatorView::initial_map_view(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
+        let mut map_view = MercatorView::initial_map_view(
+            f64::from(initial_size.0),
+            f64::from(initial_size.1),
+            tile_size,
+        );
 
         if map_view.zoom < MIN_ZOOM_LEVEL {
             map_view.zoom = MIN_ZOOM_LEVEL;
         tile_atlas.double_texture_size(cx);
         tile_atlas.double_texture_size(cx);
 
-        let tile_layer = TileLayer::new(cx, &tile_atlas);
+        let mercator_tile_layer = MercatorTileLayer::new(cx, &tile_atlas);
 
         MapViewGl {
             map_view,
             dpi_factor,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
             tile_atlas,
-            tile_layer,
+            mercator_tile_layer,
             marker_layer: MarkerLayer::new(cx),
             ortho_tile_layer: OrthoTileLayer::new(cx),
             projection: Projection::Mercator,
         };
     }
 
-    fn draw_flat_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
+    fn draw_mercator_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
         -> Result<usize, usize>
     {
         if self.last_draw_type != DrawType::Tiles {
             self.last_draw_type = DrawType::Tiles;
-            self.tile_layer.prepare_draw(cx, &self.tile_atlas);
+            self.mercator_tile_layer.prepare_draw(cx, &self.tile_atlas);
         }
 
         //TODO remove viewport_size parameter
-        self.tile_layer.draw(
+        self.mercator_tile_layer.draw(
             cx,
             &self.map_view,
             source,
 
         match self.projection {
             Projection::Mercator => {
-                let ret = self.draw_flat_tiles(cx, source, snap_to_pixel);
+                let ret = self.draw_mercator_tiles(cx, source, snap_to_pixel);
                 if !self.marker_layer.is_empty() {
                     self.draw_marker(cx, snap_to_pixel);
                 }

src/tile_layer.rs → src/mercator_tile_layer.rs

 
 
 #[derive(Debug)]
-pub struct TileLayer {
+pub struct MercatorTileLayer {
     program: Program,
     buffer: Buffer,
 }
 
 
-impl TileLayer {
+impl MercatorTileLayer {
     pub fn new(
         cx: &mut Context,
         atlas: &TileAtlas,
-    ) -> TileLayer
+    ) -> MercatorTileLayer
     {
         let buffer = Buffer::new(cx, &[], 0);
         check_gl_errors!(cx);
         );
         check_gl_errors!(cx);
 
-        TileLayer {
+        MercatorTileLayer {
             program,
             buffer,
         }