Rename tile_cache_gl -> tile_atlas

src/main.rs

 mod texture;
 mod tile;
 mod tile_cache;
-mod tile_cache_gl;
+mod tile_atlas;
 mod tile_loader;
 mod tile_source;
 

src/map_view_gl.rs

 use program::Program;
 use texture::{Texture, TextureFormat};
 use tile_cache::TileCache;
-use tile_cache_gl::TileCacheGl;
+use tile_atlas::TileAtlas;
 use tile_source::TileSource;
 
 
     viewport_size: (u32, u32),
     map_view: MapView,
     tile_cache: TileCache,
-    tile_cache_gl: TileCacheGl<'a>,
+    tile_atlas: TileAtlas<'a>,
 }
 
 impl<'a> MapViewGl<'a> {
                 viewport_size: initial_size,
                 map_view: map_view,
                 tile_cache: TileCache::new(move |_tile| update_func(), use_network),
-                tile_cache_gl: TileCacheGl::new(tex, 256),
+                tile_atlas: TileAtlas::new(tex, 256),
             }
         }
     }
 
         loop {
             let (textured_visible_tiles, remainder_opt, used_tiles) = {
-                self.tile_cache_gl.textured_visible_tiles(
+                self.tile_atlas.textured_visible_tiles(
                     remainder,
                     max_tiles_to_use,
                     source,

src/tile_cache_gl.rs → src/tile_atlas.rs

 }
 
 #[derive(Clone, Debug)]
-pub struct TileCacheGl<'a> {
+pub struct TileAtlas<'a> {
     texture: Texture<'a>,
     tile_size: u32,
     slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
     tile_to_slot: HashMap<Tile, CacheSlot>,
 }
 
-impl<'a> TileCacheGl<'a> {
+impl<'a> TileAtlas<'a> {
     pub fn new(tex: Texture<'a>, tile_size: u32) -> Self {
         let slots_x = tex.width() / tile_size;
         let slots_y = tex.height() / tile_size;
 
         slots_lru.remove(&Self::default_slot());
 
-        TileCacheGl {
+        TileAtlas {
             texture: tex,
             tile_size: tile_size,
             slots_lru: slots_lru,