Draw in multiple steps when texture atlas is too small

src/map_view_gl.rs

             center: self.map_view.center,
         });
 
-        {
-            let visible_tiles = self.map_view.visible_tiles(true);
-            let textured_visible_tiles = self.tile_cache_gl.textured_visible_tiles(
-                &visible_tiles,
-                source,
-                &mut self.tile_cache,
-            );
+        self.cx.clear_color((0.2, 0.2, 0.2, 1.0));
+
+        let visible_tiles = self.map_view.visible_tiles(true);
+        let mut remainder = visible_tiles.as_slice();
+        let mut num_draws = 0;
+        let mut max_tiles_to_use = self.tile_cache.max_tiles();
+
+        loop {
+            let (textured_visible_tiles, remainder_opt, used_tiles) = {
+                self.tile_cache_gl.textured_visible_tiles(
+                    remainder,
+                    max_tiles_to_use,
+                    source,
+                    &mut self.tile_cache,
+                )
+            };
+
+            max_tiles_to_use -= used_tiles;
 
             let mut vertex_data: Vec<f32> = Vec::with_capacity(textured_visible_tiles.len() * (6 * 8));
             let scale_x = 2.0 / f64::from(self.viewport_size.0);
             let scale_y = -2.0 / f64::from(self.viewport_size.1);
-            for tvt in textured_visible_tiles {
+            for tvt in &textured_visible_tiles {
                 let minmax = [
                     tvt.tex_minmax.x1 as f32,
                     tvt.tex_minmax.y1 as f32,
             }
 
             self.buf.set_data(&vertex_data, vertex_data.len() / 4);
-        }
+            self.buf.draw(DrawMode::Triangles);
+
+            num_draws += 1;
+            debug!("draw #{}: tvt.len() = {}, remainder = {:?}, max_tiles = {}",
+                num_draws,
+                textured_visible_tiles.len(),
+                remainder_opt.map(|r| r.len()),
+                max_tiles_to_use);
+
+            if max_tiles_to_use <= 0 {
+                warn!("tile cache is too small for this view.");
+                break;
+            }
 
-        self.cx.clear_color((0.9, 0.9, 0.9, 1.0));
-        self.buf.draw(DrawMode::Triangles);
+            match remainder_opt {
+                None => break,
+                Some(new_remainder) => {
+                    if new_remainder.len() >= remainder.len() {
+                        warn!("failed to draw all tiles. number of remaining tiles did not decrease.");
+                        break;
+                    } else {
+                        remainder = new_remainder;
+                    }
+                },
+            }
+        }
     }
 
     pub fn step_zoom(&mut self, steps: i32, step_size: f64) {

src/tile_cache.rs

         }
     }
 
+    // Return the maximum number of tiles that this cache can hold at once.
+    pub fn max_tiles(&self) -> usize {
+        self.max_tiles
+    }
+
     pub fn get_sync(
         &mut self,
         tile_coord: TileCoord,

src/tile_cache_gl.rs

         slot
     }
 
-    pub fn textured_visible_tiles(
+    /// Finds textures from the cache for a given slice of visible tiles. The texture atlas may not
+    /// be big enough to hold all textures at once; a possible remainder of untextured visible tiles is
+    /// returned as an `Option`.
+    /// The function guarantees that no more than `max_tiles_to_use` tiles are used for texturing;
+    /// the number of used tiles is returned as an `usize`.
+    pub fn textured_visible_tiles<'b>(
         &mut self,
-        visible_tiles: &[VisibleTile],
+        visible_tiles: &'b [VisibleTile],
+        max_tiles_to_use: usize,
         source: &TileSource,
         cache: &mut TileCache,
-        ) -> Vec<TexturedVisibleTile>
+        ) -> (Vec<TexturedVisibleTile>, Option<&'b [VisibleTile]>, usize)
     {
         let mut tvt = Vec::with_capacity(visible_tiles.len());
 
         let inset_x = 0.5 / f64::from(self.texture.width());
         let inset_y = 0.5 / f64::from(self.texture.height());
 
-        for vt in visible_tiles {
+        let num_usable_slots = self.slots_lru.len();
+        // The number of actually used slots may be lower, because slots can be used multiple times
+        // in the same view (especially the default slot).
+        let mut used_slots = 0_usize;
+
+        for (i, vt) in visible_tiles.iter().enumerate() {
+            if used_slots >= num_usable_slots || used_slots >= max_tiles_to_use {
+                return (tvt, Some(&visible_tiles[i..]), used_slots);
+            }
+
             if let Some(slot) = self.store(vt.tile, source, cache, true) {
                 let tex_rect = self.slot_to_texture_rect(slot);
+                used_slots += 1;
                 tvt.push(
                     TexturedVisibleTile {
                         screen_rect: vt.rect,
             } else {
                 // exact tile not found
 
+                if used_slots + 5 > num_usable_slots || used_slots + 5 > max_tiles_to_use {
+                    return (tvt, Some(&visible_tiles[i..]), used_slots);
+                }
+
                 // default tile
                 let mut tex_sub_rect = self.slot_to_texture_rect(Self::default_slot());
                 let mut tex_rect = tex_sub_rect;
                 for dist in 1..31 {
                     if let Some((parent_tile, sub_coord)) = vt.tile.parent(dist) {
                         if let Some(slot) = self.store(parent_tile, source, cache, false) {
+                            used_slots += 1;
                             tex_sub_rect = self.subslot_to_texture_rect(slot, sub_coord);
                             tex_rect = self.slot_to_texture_rect(slot);
                             break;
                 // look for cached tiles in higher zoom layers
                 for &(child_tile, child_sub_coord) in &vt.tile.children() {
                     if let Some(slot) = self.store(child_tile, source, cache, false) {
+                        used_slots += 1;
                         let tex_rect = self.slot_to_texture_rect(slot);
 
                         tvt.push(
             };
         }
 
-        tvt
+        (tvt, None, used_slots)
     }
 
     fn slot_to_texture_rect(&self, slot: CacheSlot) -> TextureRect {