Improve tile rendering in orthografic view

* Reach feature parity with mercator view:
  * Resize tile atlas to reduce draw calls
  * Fill in tiles from other zoom layers

src/map_view_gl.rs

         let atlas_tex = Texture::empty(cx, atlas_size, atlas_size, TextureFormat::Rgb8);
         check_gl_errors!(cx);
 
-        let mut tile_atlas = TileAtlas::new(cx, atlas_tex, tile_size, use_async);
-        //TODO remove this
-        tile_atlas.double_texture_size(cx);
-        tile_atlas.double_texture_size(cx);
-        tile_atlas.double_texture_size(cx);
+        let tile_atlas = TileAtlas::new(cx, atlas_tex, tile_size, use_async);
 
         let mercator_tile_layer = MercatorTileLayer::new(cx, &tile_atlas);
+        let ortho_tile_layer = OrthoTileLayer::new(cx, &tile_atlas);
 
         MapViewGl {
             map_view,
             tile_atlas,
             mercator_tile_layer,
             marker_layer: MarkerLayer::new(cx),
-            ortho_tile_layer: OrthoTileLayer::new(cx),
+            ortho_tile_layer,
             projection: Projection::Mercator,
             last_draw_type: DrawType::Null,
         }
         );
     }
 
-    fn draw_ortho_tiles(&mut self, cx: &mut Context, source: &TileSource) {
+    fn draw_ortho_tiles(&mut self, cx: &mut Context, source: &TileSource) -> Result<usize, usize> {
         if self.last_draw_type != DrawType::OrthoTiles {
             self.last_draw_type = DrawType::OrthoTiles;
             self.ortho_tile_layer.prepare_draw(cx, &self.tile_atlas);
             source,
             &mut self.tile_cache,
             &mut self.tile_atlas,
-        );
+        )
     }
 
     /// Returns `Err` when tile cache is too small for this view.
                 ret
             },
             Projection::Orthografic => {
-                self.draw_ortho_tiles(cx, source);
-                Ok(1)
+                self.draw_ortho_tiles(cx, source)
             },
         }
     }

src/mercator_tile_layer.rs

             include_bytes!("../shader/map.vert"),
             include_bytes!("../shader/map.frag"),
         ).unwrap();
-        check_gl_errors!(cx);
 
         program.add_texture(cx, atlas.texture(), CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
-        check_gl_errors!(cx);
 
         program.add_attribute(
             cx,
             CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(),
             &VertexAttribParams::new(4, 8, 4)
         );
+
         check_gl_errors!(cx);
 
         MercatorTileLayer {
                 )
             };
 
-            max_tiles_to_use -= used_tiles;
+            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);

src/mercator_view.rs

-use coord::{MapCoord, ScreenCoord, ScreenRect, TileCoord};
+use coord::{MapCoord, ScreenCoord, ScreenRect, TextureRect, TileCoord};
 use map_view::MapView;
 
 
     pub rect: ScreenRect,
 }
 
+#[derive(Clone, Debug)]
+pub struct TexturedVisibleTile {
+    pub screen_rect: ScreenRect,
+    pub tex_rect: TextureRect,
+    pub tex_minmax: TextureRect,
+}
+
+
 impl MercatorView {
     /// Constructs a `MapView` centered at Null Island with an integer zoom that fills a screen
     /// with the given dimensions.

src/ortho_tile_layer.rs

 use buffer::{Buffer, DrawMode};
 use cgmath::Transform;
 use context::Context;
-use coord::{LatLonRad, ScreenCoord, TileCoord, View};
+use coord::{LatLonRad, ScreenCoord, View};
 use map_view::MapView;
 use orthografic_view::OrthograficView;
 use program::Program;
 use std::ffi::CStr;
-use tile_atlas::TileAtlas;
+use tile_atlas::{TileAtlas, VisibleTilesProvider};
 use tile_cache::TileCache;
 use tile_source::TileSource;
 use vertex_attrib::VertexAttribParams;
 impl OrthoTileLayer {
     pub fn new(
         cx: &mut Context,
+        atlas: &TileAtlas,
     ) -> OrthoTileLayer
     {
         let buffer = Buffer::new(cx, &[], 0);
-        check_gl_errors!(cx);
         cx.bind_buffer(buffer.id());
 
         let mut program = Program::new(
             include_bytes!("../shader/ortho_tile.vert"),
             include_bytes!("../shader/ortho_tile.frag"),
         ).unwrap();
-        check_gl_errors!(cx);
+
+        program.add_texture(cx, atlas.texture(), CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
 
         program.add_attribute(
             cx,
             CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(),
             &VertexAttribParams::new(4, 9, 5)
         );
+
         check_gl_errors!(cx);
 
         OrthoTileLayer {
         source: &TileSource,
         cache: &mut TileCache,
         tile_atlas: &mut TileAtlas,
-    ) {
+    ) -> Result<usize, usize> {
         //TODO Add distance function to TileCache that takes topology of the sphere into account.
         cache.set_view_location(View {
             source_id: source.id(),
             center: map_view.center,
         });
 
-        let mut vertex_data = vec![];
-
         let transform = OrthograficView::transformation_matrix(map_view);
 
-        let (inset_x, inset_y) = tile_atlas.texture_margins();
-
-        for tile_coord in OrthograficView::visible_tiles(map_view).into_iter() {
-            let slot = tile_atlas.store(cx, tile_coord, source, cache, true)
-                .unwrap_or_else(TileAtlas::default_slot);
-            let texrect = tile_atlas.slot_to_texture_rect(slot);
-            let tex_minmax = texrect.inset(inset_x, inset_y);
-
-            let minmax = [
-                tex_minmax.x1 as f32,
-                tex_minmax.y1 as f32,
-                tex_minmax.x2 as f32,
-                tex_minmax.y2 as f32,
-            ];
-
-            let subdivision = 6u32.saturating_sub(tile_coord.zoom).max(2);
-
-            for (tc, sub_tile) in tile_coord.children_iter(subdivision) {
-                let ll_nw = tc.latlon_rad_north_west();
-                let ll_se = {
-                    let tc = TileCoord::new(tc.zoom, tc.x + 1, tc.y + 1);
-                    tc.latlon_rad_north_west()
-                };
-
-                let ll_ne = LatLonRad::new(ll_nw.lat, ll_se.lon);
-                let ll_sw = LatLonRad::new(ll_se.lat, ll_nw.lon);
-
-                let p1 = ll_nw.to_sphere_point3();
-                let p2 = ll_ne.to_sphere_point3();
-                let p3 = ll_se.to_sphere_point3();
-                let p4 = ll_sw.to_sphere_point3();
-
-                let p1 = transform.transform_point(p1);
-                let p2 = transform.transform_point(p2);
-                let p3 = transform.transform_point(p3);
-                let p4 = transform.transform_point(p4);
-
-                // Discard tiles that are facing backwards
-                if (p1.z + p3.z) * 0.5 > 0.0 {
-                    continue;
+        let visible_tiles = OrthograficView::visible_tiles(map_view);
+        let mut remainder = visible_tiles.as_slice();
+        let mut num_draws = 0;
+        let mut max_tiles_to_use = cache.max_tiles();
+
+        loop {
+            let (textured_visible_tiles, remainder_opt, used_tiles) = {
+                tile_atlas.textured_visible_tiles(
+                    cx,
+                    remainder,
+                    max_tiles_to_use,
+                    source,
+                    cache,
+                )
+            };
+
+            max_tiles_to_use = max_tiles_to_use.saturating_sub(used_tiles);
+
+            // A low guess for the capacity
+            let mut vertex_data = Vec::with_capacity(textured_visible_tiles.len() * 9 * 16);
+
+            for tvt in &textured_visible_tiles {
+                let minmax = [
+                    tvt.tex_minmax.x1 as f32,
+                    tvt.tex_minmax.y1 as f32,
+                    tvt.tex_minmax.x2 as f32,
+                    tvt.tex_minmax.y2 as f32,
+                ];
+
+                let subdivision = 6u32.saturating_sub(tvt.tile_coord.zoom).max(2);
+
+                for (tc, sub_tile) in tvt.tile_coord.children_iter(subdivision) {
+                    let ll_nw = tc.latlon_rad_north_west();
+                    let ll_se = tc.latlon_rad_south_east();
+                    let ll_ne = LatLonRad::new(ll_nw.lat, ll_se.lon);
+                    let ll_sw = LatLonRad::new(ll_se.lat, ll_nw.lon);
+
+                    let p1 = transform.transform_point(ll_nw.to_sphere_point3());
+                    let p2 = transform.transform_point(ll_ne.to_sphere_point3());
+                    let p3 = transform.transform_point(ll_se.to_sphere_point3());
+                    let p4 = transform.transform_point(ll_sw.to_sphere_point3());
+
+                    // Discard tiles/subtiles that are facing backwards
+                    if (p1.z + p3.z) * 0.5 > 0.0 {
+                        continue;
+                    }
+
+                    let texrect = tvt.tex_rect.subdivide(&sub_tile);
+
+                    let p1 = [p1.x as f32, p1.y as f32, p1.z as f32, texrect.x1 as f32, texrect.y1 as f32];
+                    let p2 = [p2.x as f32, p2.y as f32, p2.z as f32, texrect.x2 as f32, texrect.y1 as f32];
+                    let p3 = [p3.x as f32, p3.y as f32, p3.z as f32, texrect.x2 as f32, texrect.y2 as f32];
+                    let p4 = [p4.x as f32, p4.y as f32, p4.z as f32, texrect.x1 as f32, texrect.y2 as f32];
+
+                    vertex_data.extend(&p1);
+                    vertex_data.extend(&minmax);
+                    vertex_data.extend(&p2);
+                    vertex_data.extend(&minmax);
+                    vertex_data.extend(&p3);
+                    vertex_data.extend(&minmax);
+                    vertex_data.extend(&p1);
+                    vertex_data.extend(&minmax);
+                    vertex_data.extend(&p3);
+                    vertex_data.extend(&minmax);
+                    vertex_data.extend(&p4);
+                    vertex_data.extend(&minmax);
                 }
+            }
 
-                let texrect = texrect.subdivide(&sub_tile);
-
-                let p1 = [p1.x as f32, p1.y as f32, p1.z as f32, texrect.x1 as f32, texrect.y1 as f32];
-                let p2 = [p2.x as f32, p2.y as f32, p2.z as f32, texrect.x2 as f32, texrect.y1 as f32];
-                let p3 = [p3.x as f32, p3.y as f32, p3.z as f32, texrect.x2 as f32, texrect.y2 as f32];
-                let p4 = [p4.x as f32, p4.y as f32, p4.z as f32, texrect.x1 as f32, texrect.y2 as f32];
-
-                vertex_data.extend(&p1);
-                vertex_data.extend(&minmax);
-                vertex_data.extend(&p2);
-                vertex_data.extend(&minmax);
-                vertex_data.extend(&p3);
-                vertex_data.extend(&minmax);
-                vertex_data.extend(&p1);
-                vertex_data.extend(&minmax);
-                vertex_data.extend(&p3);
-                vertex_data.extend(&minmax);
-                vertex_data.extend(&p4);
-                vertex_data.extend(&minmax);
+            self.buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
+            self.buffer.draw(cx, &self.program, 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.");
+                return Err(num_draws);
             }
-        }
 
-        self.buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
-        self.buffer.draw(cx, &self.program, DrawMode::Triangles);
+            match remainder_opt {
+                None => return Ok(num_draws),
+                Some(new_remainder) => {
+                    if new_remainder.len() >= remainder.len() {
+                        warn!("failed to draw all tiles. number of remaining tiles did not decrease.");
+                        return Err(num_draws);
+                    } else {
+                        remainder = new_remainder;
+                    }
+                },
+            }
+        }
     }
 }

src/orthografic_view.rs

 use cgmath::{Matrix3, Point3, Transform, vec3};
-use coord::{LatLonRad, TileCoord};
+use coord::{LatLonRad, TextureRect, TileCoord};
 use map_view::MapView;
 use std::collections::HashSet;
 use std::f32::consts::{PI, FRAC_1_PI};
 use std::f64;
 
 
+#[derive(Clone, Debug)]
+pub struct VisibleTile {
+    pub tile: TileCoord,
+}
+
+impl From<TileCoord> for VisibleTile {
+    fn from(tc: TileCoord) -> Self {
+        VisibleTile {
+            tile: tc,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TexturedVisibleTile {
+    pub tile_coord: TileCoord,
+    pub tex_rect: TextureRect,
+    pub tex_minmax: TextureRect,
+}
+
+
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
 pub enum TileNeighbor {
     Coord(TileCoord),
 
     //TODO Return the transformation matrix that is used here to avoid redundant calculation.
     /// Returns a `Vec` of all tiles that are visible in the current viewport.
-    pub fn visible_tiles(map_view: &MapView) -> Vec<TileCoord> {
+    pub fn visible_tiles(map_view: &MapView) -> Vec<VisibleTile> {
         let uzoom = Self::tile_zoom(map_view);
 
         match uzoom {
-            0 => return vec![TileCoord::new(0, 0, 0)],
+            0 => return vec![TileCoord::new(0, 0, 0).into()],
             1 => {
                 // return every tile
                 return vec![
-                    TileCoord::new(1, 0, 0),
-                    TileCoord::new(1, 0, 1),
-                    TileCoord::new(1, 1, 0),
-                    TileCoord::new(1, 1, 1),
+                    TileCoord::new(1, 0, 0).into(),
+                    TileCoord::new(1, 0, 1).into(),
+                    TileCoord::new(1, 1, 0).into(),
+                    TileCoord::new(1, 1, 1).into(),
                 ]},
             _ => {},
         }
             }
         };
 
-        let mut tiles = vec![center_tile];
+        let mut tiles = vec![center_tile.into()];
 
         let mut stack: Vec<TileNeighbor> = vec![];
         tile_neighbors(center_tile, &mut stack);
         visited.insert(TileNeighbor::Coord(center_tile));
         visited.extend(stack.iter());
 
-        let mut neighbors = vec![];
+        let mut neighbors = Vec::with_capacity(4);
 
         loop {
             if let Some(tn) = stack.pop() {
                 match tn {
                     TileNeighbor::Coord(tc) => {
                         if tile_is_visible(tc) {
-                            tiles.push(tc);
+                            tiles.push(tc.into());
                             tile_neighbors(tc, &mut neighbors);
                             for tn in &neighbors {
                                 if !visited.contains(tn) {

src/tile_atlas.rs

 use context::Context;
-use coord::{ScreenRect, SubTileCoord, TileCoord, TextureRect};
+use coord::{SubTileCoord, TileCoord, TextureRect};
 use image;
 use linked_hash_map::LinkedHashMap;
 use mercator_view;
+use orthografic_view;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use texture::Texture;
 use tile_cache::TileCache;
 use tile_source::TileSource;
 
-#[derive(Clone, Debug)]
-pub struct TexturedVisibleTile {
-    pub screen_rect: ScreenRect,
-    pub tex_rect: TextureRect,
-    pub tex_minmax: TextureRect,
-}
 
 #[derive(Clone, Debug)]
 pub struct TileAtlas {
     pub y: u32,
 }
 
-pub trait VisibleTilesProvider<T> {
+/// U: Untextured Visible tile type
+/// T: Textured visible tile type
+pub trait VisibleTilesProvider<U, T> {
     /// 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`.
     fn textured_visible_tiles<'b>(
         &mut self,
         cx: &mut Context,
-        visible_tiles: &'b [T],
+        visible_tiles: &'b [U],
         max_tiles_to_use: usize,
         source: &TileSource,
         cache: &mut TileCache,
-    ) -> (Vec<TexturedVisibleTile>, Option<&'b [T]>, usize);
+    ) -> (Vec<T>, Option<&'b [U]>, usize);
 }
 
-impl VisibleTilesProvider<mercator_view::VisibleTile> for TileAtlas {
+impl VisibleTilesProvider<mercator_view::VisibleTile, mercator_view::TexturedVisibleTile>
+for TileAtlas {
     fn textured_visible_tiles<'b>(
         &mut self,
         cx: &mut Context,
         max_tiles_to_use: usize,
         source: &TileSource,
         cache: &mut TileCache,
-        ) -> (Vec<TexturedVisibleTile>, Option<&'b [mercator_view::VisibleTile]>, usize)
+    ) -> (Vec<mercator_view::TexturedVisibleTile>, Option<&'b [mercator_view::VisibleTile]>, usize)
     {
         let mut tvt = Vec::with_capacity(visible_tiles.len());
 
                 let tex_rect = self.slot_to_texture_rect(slot);
                 used_slots += 1;
                 tvt.push(
-                    TexturedVisibleTile {
+                    mercator_view::TexturedVisibleTile {
                         screen_rect: vt.rect,
                         tex_rect,
                         tex_minmax: tex_rect.inset(inset_x, inset_y),
                         let tex_rect = self.slot_to_texture_rect(slot);
 
                         tvt.push(
-                            TexturedVisibleTile {
+                            mercator_view::TexturedVisibleTile {
                                 screen_rect: vt.rect.subdivide(&child_sub_coord),
                                 tex_rect,
                                 tex_minmax: tex_rect.inset(inset_x, inset_y),
                         );
                     } else {
                         tvt.push(
-                            TexturedVisibleTile {
+                            mercator_view::TexturedVisibleTile {
                                 screen_rect: vt.rect.subdivide(&child_sub_coord),
                                 tex_rect: tex_sub_rect.subdivide(&child_sub_coord),
                                 tex_minmax: tex_rect.inset(inset_x, inset_y),
         (tvt, None, used_slots)
     }
 }
+
+impl VisibleTilesProvider<orthografic_view::VisibleTile, orthografic_view::TexturedVisibleTile>
+for TileAtlas {
+    fn textured_visible_tiles<'b>(
+        &mut self,
+        cx: &mut Context,
+        visible_tiles: &'b [orthografic_view::VisibleTile],
+        max_tiles_to_use: usize,
+        source: &TileSource,
+        cache: &mut TileCache,
+    ) -> (Vec<orthografic_view::TexturedVisibleTile>, Option<&'b [orthografic_view::VisibleTile]>,
+          usize)
+    {
+        let mut tvt = Vec::with_capacity(visible_tiles.len());
+
+        let (inset_x, inset_y) = self.texture_margins();
+
+        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(cx, vt.tile, source, cache, true) {
+                let tex_rect = self.slot_to_texture_rect(slot);
+                used_slots += 1;
+                tvt.push(
+                    orthografic_view::TexturedVisibleTile {
+                        tile_coord: vt.tile,
+                        tex_rect,
+                        tex_minmax: tex_rect.inset(inset_x, inset_y),
+                    }
+                );
+            } 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;
+
+                // look for cached tiles in lower zoom layers
+                for dist in 1..31 {
+                    if let Some((parent_tile, sub_coord)) = vt.tile.parent(dist) {
+                        if let Some(slot) = self.store(cx, 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;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+
+                // look for cached tiles in higher zoom layers
+                //TODO Just create one rect (instead of four) if there is no tile from a higher
+                // zoom level available
+                for (child_tile, child_sub_coord) in vt.tile.children_iter(1) {
+                    if let Some(slot) = self.store(cx, child_tile, source, cache, false) {
+                        used_slots += 1;
+                        let tex_rect = self.slot_to_texture_rect(slot);
+
+                        tvt.push(
+                            orthografic_view::TexturedVisibleTile {
+                                tile_coord: child_tile,
+                                tex_rect,
+                                tex_minmax: tex_rect.inset(inset_x, inset_y),
+                            }
+                        );
+                    } else {
+                        tvt.push(
+                            orthografic_view::TexturedVisibleTile {
+                                tile_coord: child_tile,
+                                tex_rect: tex_sub_rect.subdivide(&child_sub_coord),
+                                tex_minmax: tex_rect.inset(inset_x, inset_y),
+                            }
+                        );
+                    }
+                }
+            };
+        }
+
+        (tvt, None, used_slots)
+    }
+}