Increase tile atlas size when needed

src/main.rs

@@ -273,6 +273,7 @@ fn main() {
     // estimated draw duration
     let mut est_draw_dur = duration_per_frame;
     let mut last_draw = Instant::now();
+    let mut increase_atlas_size = true;
 
     'outer: for event in window.wait_events() {
         debug!("{:?}", &event);
@@ -321,11 +322,25 @@ fn main() {
 
         if redraw {
             let draw_start = Instant::now();
-            map.draw(sources.current());
+            let draw_result = map.draw(sources.current());
             let draw_dur = draw_start.elapsed();
 
             let _ = window.swap_buffers();
 
+            //TODO increase atlas size earlier to avoid excessive copying to the GPU
+            //TODO increase max tile cache size?
+            increase_atlas_size = {
+                match (draw_result, increase_atlas_size) {
+                    (Err(draws), true) if draws > 1 => {
+                        map.increase_atlas_size().is_ok()
+                    },
+                    (Ok(draws), true) if draws > 1 => {
+                        map.increase_atlas_size().is_ok()
+                    },
+                    _ => increase_atlas_size,
+                }
+            };
+
             last_draw = Instant::now();
 
             debug!("draw: {} sec (est {} sec)", dur_to_sec(draw_dur), dur_to_sec(est_draw_dur));

src/map_view_gl.rs

@@ -3,7 +3,6 @@ use ::std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
 use context::Context;
 use coord::{ScreenCoord, View};
-use image;
 use map_view::MapView;
 use program::Program;
 use texture::{Texture, TextureFormat};
@@ -31,13 +30,8 @@ impl<'a> MapViewGl<'a> {
             let mut program = Program::from_paths(cx, "shader/map.vert", "shader/map.frag");
 
             check_gl_errors!(cx);
-            let mut tex = Texture::empty(cx, 2048, 2048, TextureFormat::Rgb8);
+            let tex = Texture::empty(cx, 2048, 2048, TextureFormat::Rgb8);
             check_gl_errors!(cx);
-            {
-                let img = image::open("img/no_tile.png").unwrap();
-                tex.sub_image(0, 0, &img);
-                check_gl_errors!(cx);
-            }
 
             let buf = Buffer::new(cx, &[], 0);
 
@@ -89,7 +83,14 @@ impl<'a> MapViewGl<'a> {
         }
     }
 
-    pub fn draw(&mut self, source: &TileSource) {
+    pub fn increase_atlas_size(&mut self) -> Result<(), ()> {
+        self.tile_atlas.double_texture_size()
+    }
+
+    /// Returns `Err` when tile cache is too small for this view.
+    /// Returns the number of OpenGL draw calls, which can be decreased to `1` by increasing the
+    /// size of the tile atlas.
+    pub fn draw(&mut self, source: &TileSource) -> Result<usize, usize> {
         self.tile_cache.set_view_location(View {
             source_id: source.id(),
             zoom: self.map_view.tile_zoom(),
@@ -167,6 +168,7 @@ impl<'a> MapViewGl<'a> {
             self.buf.draw(DrawMode::Triangles);
 
             num_draws += 1;
+
             debug!("draw #{}: tvt.len() = {}, remainder = {:?}, max_tiles = {}",
                 num_draws,
                 textured_visible_tiles.len(),
@@ -175,15 +177,15 @@ impl<'a> MapViewGl<'a> {
 
             if max_tiles_to_use <= 0 {
                 warn!("tile cache is too small for this view.");
-                break;
+                return Err(num_draws);
             }
 
             match remainder_opt {
-                None => break,
+                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.");
-                        break;
+                        return Err(num_draws);
                     } else {
                         remainder = new_remainder;
                     }

src/texture.rs

@@ -10,6 +10,7 @@ pub struct Texture<'a> {
     texture_obj: u32,
     width: u32,
     height: u32,
+    format: TextureFormat,
 }
 
 #[derive(Clone, Debug)]
@@ -64,6 +65,7 @@ impl<'a> Texture<'a> {
             texture_obj: tex_obj,
             width: width,
             height: height,
+            format: format,
         }
     }
 
@@ -90,6 +92,25 @@ impl<'a> Texture<'a> {
         }
     }
 
+    pub fn resize(&mut self, width: u32, height: u32) {
+        unsafe {
+            self.cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
+            self.cx.gl.TexImage2D(
+                context::gl::TEXTURE_2D,
+                0, // level
+                self.format.to_gl_enum() as i32,
+                width as i32,
+                height as i32,
+                0, // border (must be zero)
+                self.format.to_gl_enum(),
+                context::gl::UNSIGNED_BYTE,
+                ::std::ptr::null() as *const _);
+
+            self.width = width;
+            self.height = height;
+        }
+    }
+
     pub fn id(&self) -> TextureId {
         TextureId {
             id: self.texture_obj,
@@ -103,6 +124,10 @@ impl<'a> Texture<'a> {
     pub fn height(&self) -> u32 {
         self.height
     }
+
+    pub fn context(&self) -> &Context {
+        self.cx
+    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]

src/tile_atlas.rs

@@ -1,4 +1,5 @@
 use coord::{ScreenRect, SubTileCoord, TileCoord, TextureRect};
+use image;
 use linked_hash_map::LinkedHashMap;
 use map_view::VisibleTile;
 use std::collections::HashMap;
@@ -24,26 +25,60 @@ pub struct TileAtlas<'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;
+    fn init(&mut self) {
+        // add tile for default slot
+        {
+            let img = image::open("img/no_tile.png").unwrap();
+            self.texture.sub_image(0, 0, &img);
+        }
+
+        let slots_x = self.texture.width() / self.tile_size;
+        let slots_y = self.texture.height() / self.tile_size;
         let num_slots = (slots_x * slots_y) as usize;
 
-        let mut slots_lru = LinkedHashMap::with_capacity(num_slots);
+        self.slots_lru.clear();
+        self.slots_lru.reserve(num_slots);
         for x in 0..slots_x {
             for y in 0..slots_y {
                 let slot = CacheSlot { x: x, y: y };
-                slots_lru.insert(slot, None);
+                self.slots_lru.insert(slot, None);
             }
         }
+        self.slots_lru.remove(&Self::default_slot());
 
-        slots_lru.remove(&Self::default_slot());
+        self.tile_to_slot.clear();
+        self.tile_to_slot.reserve(num_slots);
+    }
 
-        TileAtlas {
+    pub fn new(tex: Texture<'a>, tile_size: u32) -> Self {
+        let mut atlas = TileAtlas {
             texture: tex,
             tile_size: tile_size,
-            slots_lru: slots_lru,
-            tile_to_slot: HashMap::with_capacity(num_slots),
+            slots_lru: LinkedHashMap::new(),
+            tile_to_slot: HashMap::new(),
+        };
+
+        atlas.init();
+        atlas
+    }
+
+    pub fn double_texture_size(&mut self) -> Result<(), ()> {
+        let max_size = self.texture.context().max_texture_size() as u32;
+
+        let new_width = self.texture.width() * 2;
+        let new_height = self.texture.height() * 2;
+
+        if new_width <= max_size && new_height <= max_size {
+            self.texture.resize(new_width, new_height);
+
+            // remove old entries, initialize texture
+            self.init();
+
+            info!("new atlas size {}x{}", new_width, new_height);
+
+            Ok(())
+        } else {
+            Err(())
         }
     }