Add globe view mode, partially solve tile visibility

* Toggle between ViewMode::Flat and ViewMode::Globe with Ctrl+G
* Approach tile visibility problem at the sphere

src/globe_tile_layer.rs

@@ -1,7 +1,6 @@
-use std::f32::consts::{PI, FRAC_1_PI};
 use std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
-use cgmath::{Matrix3, Point3, Transform, vec3};
+use cgmath::Transform;
 use context::Context;
 use coord::{LatLonRad, TileCoord, View};
 use map_view::MapView;
@@ -72,8 +71,8 @@ impl GlobeTileLayer {
         source: &TileSource,
         cache: &mut TileCache,
         tile_atlas: &mut TileAtlas,
-        viewport_size: (u32, u32),
     ) {
+        //TODO Add distance function to TileCache that takes topology of the sphere into account.
         cache.set_view_location(View {
             source_id: source.id(),
             zoom: map_view.tile_zoom(),
@@ -82,106 +81,69 @@ impl GlobeTileLayer {
 
         let mut vertex_data = vec![];
 
-        let (scale_x, scale_y) = {
-            let factor = 2.0f32.powf(map_view.zoom as f32) *
-                (FRAC_1_PI * map_view.tile_size as f32);
-            (factor / viewport_size.0 as f32, factor / viewport_size.1 as f32)
-        };
-
-        let scale_mat: Matrix3<f32> = Matrix3::from_cols(
-            vec3(scale_x, 0.0, 0.0),
-            vec3(0.0, scale_y, 0.0),
-            vec3(0.0, 0.0, 1.0),
-        );
-
-        let rot_mat_x: Matrix3<f32> = {
-            let center_latlon = map_view.center.to_latlon_rad();
-            let alpha = center_latlon.lon as f32 + (PI * 0.5);
-            let cosa = alpha.cos();
-            let sina = alpha.sin();
-                Matrix3::from_cols(
-                vec3(cosa, 0.0, -sina),
-                vec3(0.0, 1.0, 0.0),
-                vec3(sina, 0.0, cosa),
-            )
-        };
-
-        let rot_mat_y: Matrix3<f32> = {
-            let center_latlon = map_view.center.to_latlon_rad();
-            let alpha = (-center_latlon.lat) as f32;
-            let cosa = alpha.cos();
-            let sina = alpha.sin();
-                Matrix3::from_cols(
-                vec3(1.0, 0.0, 0.0),
-                vec3(0.0, cosa, sina),
-                vec3(0.0, -sina, cosa),
-            )
-        };
-
-        let transform = Transform::<Point3<f32>>::concat(&rot_mat_y, &rot_mat_x);
-        let transform = Transform::<Point3<f32>>::concat(&scale_mat, &transform);
+        let transform = map_view.globe_transformation_matrix();
 
         let (inset_x, inset_y) = tile_atlas.texture_margins();
 
-        for tile_y in 0..8 {
-            for tile_x in 0..8 {
-                let tc = TileCoord::new(3, tile_x, tile_y);
-                let slot = tile_atlas.store(cx, tc, 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,
-                ];
-
-                for (tc, sub_tile) in tc.children_iter(3) {
-                    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(1.0);
-                    let p2 = ll_ne.to_sphere_point3(1.0);
-                    let p3 = ll_se.to_sphere_point3(1.0);
-                    let p4 = ll_sw.to_sphere_point3(1.0);
-
-                    let p1 = transform.transform_point(p1);
-                    let p2 = transform.transform_point(p2);
-                    let p3 = transform.transform_point(p3);
-                    let p4 = transform.transform_point(p4);
-
-                    if p1.z > 0.0 && p2.z > 0.0 && p3.z > 0.0 && p4.z > 0.0 {
-                        continue;
-                    }
-
-                    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);
+        for tile_coord in map_view.visible_globe_tiles().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(1.0);
+                let p2 = ll_ne.to_sphere_point3(1.0);
+                let p3 = ll_se.to_sphere_point3(1.0);
+                let p4 = ll_sw.to_sphere_point3(1.0);
+
+                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 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);
             }
         }
 

src/main.rs

@@ -194,6 +194,14 @@ fn handle_event(
                         }
                         Action::Redraw
                     },
+                    VirtualKeyCode::G => {
+                        if modifiers.ctrl {
+                            map.toggle_view_mode();
+                            Action::Redraw
+                        } else {
+                            Action::Nothing
+                        }
+                    },
                     _ => Action::Nothing,
                 }
             },
@@ -365,7 +373,7 @@ fn run() -> Result<(), Box<Error>> {
         if redraw {
             let draw_start = Instant::now();
 
-            if !map.viewport_in_map() {
+            if !map.map_covers_viewport() {
                 cx.clear_color((0.2, 0.2, 0.2, 1.0));
             }
             let draw_result = map.draw(&mut cx, sources.current());

src/map_view.rs

@@ -1,4 +1,7 @@
+use cgmath::{Matrix3, Point3, Transform, vec3};
 use coord::{MapCoord, ScreenCoord, ScreenRect, TileCoord};
+use std::f32::consts::{PI, FRAC_1_PI};
+use std::f64;
 
 
 /// A view of a tiled map with a rectangular viewport and a zoom.
@@ -79,7 +82,7 @@ impl MapView {
     }
 
     /// Returns true if the viewport rectangle is fully inside the map.
-    pub fn viewport_in_map(&self) -> bool {
+    pub fn map_covers_viewport(&self) -> bool {
         let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
 
         let y_top = self.center.y + -0.5 * self.height * scale;
@@ -88,6 +91,16 @@ impl MapView {
         y_top >= 0.0 && y_bottom <= 1.0
     }
 
+    /// Returns true if the globe rendering covers the whole viewport.
+    pub fn globe_covers_viewport(&self) -> bool {
+        //TODO Add a little safety margin since the rendered globe is not a perfect sphere and its
+        // screen area is underestimated by the tesselation.
+        let globe_diameter = 2.0f64.powf(self.zoom) *
+            (f64::consts::FRAC_1_PI * self.tile_size as f64);
+
+        return (self.width * self.width) + (self.height * self.height) < globe_diameter * globe_diameter;
+    }
+
     /// Returns the screen coordinate of the top-left corner of a tile.
     pub fn tile_screen_position(&self, tile: &TileCoord) -> ScreenCoord {
         self.map_to_screen_coord(tile.map_coord_north_west())
@@ -133,6 +146,95 @@ impl MapView {
         visible_tiles
     }
 
+    //TODO Put this in a new module with other "sphere things"
+    /// Returns a `Vec` of all tiles that are visible in the current viewport.
+    pub fn visible_globe_tiles(&self) -> Vec<TileCoord> {
+        let uzoom = self.tile_zoom();
+
+        match uzoom {
+            0 => return vec![TileCoord::new(0, 0, 0)],
+            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),
+                ]},
+            _ => {},
+        }
+
+        let center_tile = self.center.on_tile_at_zoom(uzoom).globe_norm();
+
+
+        let mut tiles = vec![];
+        tiles.push(center_tile);
+
+        // Check rings of tiles with the same Chebyshev distance to the center_tile
+        {
+            let zoom_level_tiles = TileCoord::get_zoom_level_tiles(uzoom);
+            let max_full_rings = (zoom_level_tiles - 1) / 2;
+
+            for radius in 1..3.min(max_full_rings + 1) {
+                let (rx1, rx2) = (center_tile.x - radius, center_tile.x + radius);
+                let (ry1, ry2) = (center_tile.y - radius, center_tile.y + radius);
+
+                for x in rx1..rx2+1 {
+                    tiles.push(TileCoord::new(uzoom, x, ry1).globe_norm());
+                    tiles.push(TileCoord::new(uzoom, x, ry2).globe_norm());
+                }
+                for y in ry1+1..ry2 {
+                    tiles.push(TileCoord::new(uzoom, rx1, y).globe_norm());
+                    tiles.push(TileCoord::new(uzoom, rx2, y).globe_norm());
+                }
+            }
+        }
+
+        tiles
+    }
+
+    pub fn globe_transformation_matrix(&self) -> Matrix3<f32> {
+        let (scale_x, scale_y) = {
+            let factor = 2.0f32.powf(self.zoom as f32) *
+                (FRAC_1_PI * self.tile_size as f32);
+            (factor / self.width as f32, factor / self.height as f32)
+        };
+
+        let scale_mat: Matrix3<f32> = Matrix3::from_cols(
+            vec3(scale_x, 0.0, 0.0),
+            vec3(0.0, scale_y, 0.0),
+            vec3(0.0, 0.0, 1.0),
+        );
+
+        let rot_mat_x: Matrix3<f32> = {
+            let center_latlon = self.center.to_latlon_rad();
+            let alpha = center_latlon.lon as f32 + (PI * 0.5);
+            let cosa = alpha.cos();
+            let sina = alpha.sin();
+                Matrix3::from_cols(
+                vec3(cosa, 0.0, -sina),
+                vec3(0.0, 1.0, 0.0),
+                vec3(sina, 0.0, cosa),
+            )
+        };
+
+        let rot_mat_y: Matrix3<f32> = {
+            let center_latlon = self.center.to_latlon_rad();
+            let alpha = (-center_latlon.lat) as f32;
+            let cosa = alpha.cos();
+            let sina = alpha.sin();
+                Matrix3::from_cols(
+                vec3(1.0, 0.0, 0.0),
+                vec3(0.0, cosa, sina),
+                vec3(0.0, -sina, cosa),
+            )
+        };
+
+        let transform = Transform::<Point3<f32>>::concat(&rot_mat_y, &rot_mat_x);
+        let transform = Transform::<Point3<f32>>::concat(&scale_mat, &transform);
+        transform
+    }
+
     /// Returns the tile zoom value that is used for rendering with the current zoom.
     pub fn tile_zoom(&self) -> u32 {
         (self.zoom + self.tile_zoom_offset).floor().max(0.0) as u32

src/map_view_gl.rs

@@ -23,9 +23,16 @@ pub struct MapViewGl {
     tile_layer: TileLayer,
     marker_layer: MarkerLayer,
     globe_tile_layer: GlobeTileLayer,
+    view_mode: ViewMode,
     last_draw_type: DrawType,
 }
 
+#[derive(Debug, Eq, PartialEq)]
+enum ViewMode {
+    Flat,
+    Globe,
+}
+
 #[derive(Debug, Eq, PartialEq)]
 enum DrawType {
     Null,
@@ -85,6 +92,7 @@ impl MapViewGl {
             tile_layer,
             marker_layer: MarkerLayer::new(cx),
             globe_tile_layer: GlobeTileLayer::new(cx),
+            view_mode: ViewMode::Flat,
             last_draw_type: DrawType::Null,
         }
     }
@@ -99,15 +107,25 @@ impl MapViewGl {
         self.marker_layer.add_marker(map_coord);
     }
 
-    pub fn viewport_in_map(&self) -> bool {
-        self.map_view.viewport_in_map()
+    pub fn map_covers_viewport(&self) -> bool {
+        match self.view_mode {
+            ViewMode::Flat => self.map_view.map_covers_viewport(),
+            ViewMode::Globe => self.map_view.globe_covers_viewport(),
+        }
     }
 
     pub fn increase_atlas_size(&mut self, cx: &mut Context) -> Result<(), ()> {
         self.tile_atlas.double_texture_size(cx)
     }
 
-    fn draw_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
+    pub fn toggle_view_mode(&mut self) {
+        self.view_mode = match self.view_mode {
+            ViewMode::Flat => ViewMode::Globe,
+            ViewMode::Globe => ViewMode::Flat,
+        };
+    }
+
+    fn draw_flat_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
         -> Result<usize, usize>
     {
         if self.last_draw_type != DrawType::Tiles {
@@ -115,6 +133,7 @@ impl MapViewGl {
             self.tile_layer.prepare_draw(cx, &self.tile_atlas);
         }
 
+        //TODO remove viewport_size parameter
         self.tile_layer.draw(
             cx,
             &self.map_view,
@@ -132,6 +151,7 @@ impl MapViewGl {
             self.marker_layer.prepare_draw(cx);
         }
 
+        //TODO remove viewport_size parameter
         self.marker_layer.draw(cx, &self.map_view, self.viewport_size, snap_to_pixel);
     }
 
@@ -147,7 +167,6 @@ impl MapViewGl {
             source,
             &mut self.tile_cache,
             &mut self.tile_atlas,
-            self.viewport_size,
         );
     }
 
@@ -158,15 +177,19 @@ impl MapViewGl {
         // only snap to pixel grid if zoom has integral value
         let snap_to_pixel = (self.map_view.zoom - (self.map_view.zoom + 0.5).floor()).abs() < 1e-10;
 
-        let ret = self.draw_tiles(cx, source, snap_to_pixel);
-
-        if !self.marker_layer.is_empty() {
-            self.draw_marker(cx, snap_to_pixel);
+        match self.view_mode {
+            ViewMode::Flat => {
+                let ret = self.draw_flat_tiles(cx, source, snap_to_pixel);
+                if !self.marker_layer.is_empty() {
+                    self.draw_marker(cx, snap_to_pixel);
+                }
+                ret
+            },
+            ViewMode::Globe => {
+                self.draw_globe(cx, source);
+                Ok(1)
+            },
         }
-
-        self.draw_globe(cx, source);
-
-        ret
     }
 
     pub fn step_zoom(&mut self, steps: i32, step_size: f64) {