Spherical tile visibility, part II

Still not solved. Tried to approach by calculating properties of
elliptical arcs, but there are so many edge cases...

src/coord.rs

         }
     }
 
-    pub fn to_sphere_xyz(&self, radius: f64) -> SphereXYZ {
+    /// Convert to 3D Point on unit sphere.
+    pub fn to_sphere_xyz(&self) -> SphereXYZ {
         SphereXYZ {
-            x: radius * self.lat.cos() * self.lon.cos(),
-            y: radius * self.lat.sin(),
-            z: radius * self.lat.cos() * self.lon.sin(),
+            x: self.lat.cos() * self.lon.cos(),
+            y: self.lat.sin(),
+            z: self.lat.cos() * self.lon.sin(),
         }
     }
 
-    pub fn to_sphere_point3(&self, radius: f64) -> Point3<f32> {
-        let p = self.to_sphere_xyz(radius);
+    /// Convert to 3D Point on unit sphere.
+    pub fn to_sphere_point3(&self) -> Point3<f32> {
+        let p = self.to_sphere_xyz();
         Point3::new(
             p.x as f32,
             p.y as f32,
         }
     }
 
+    /// Return the coordinate inside the tile that is nearest to the given coordinate.
+    /// This function uses spherical topology.
+    pub fn nearest_inside_point(&self, other: MapCoord) -> MapCoord {
+        //TODO insert real implemenation here
+        self.map_coord_north_west()
+    }
+
     pub fn children(&self) -> [(TileCoord, SubTileCoord); 4] {
         [
             (
         assert_eq!(TileCoord::new(2, 0, -1).globe_norm(), TileCoord::new(2, 2, 0));
         assert_eq!(TileCoord::new(2, 0, -5).globe_norm(), TileCoord::new(2, 0, 3));
     }
+
+    #[test]
+    fn nearest_inside_point() {
+        assert_eq!(TileCoord::new(0, 0, 0).nearest_inside_point(MapCoord::new(0.5, 0.25)), MapCoord::new(0.5, 0.25));
+        assert_eq!(TileCoord::new(2, 0, 0).nearest_inside_point(MapCoord::new(0.5, 0.5)), MapCoord::new(0.25, 0.25));
+        //TODO Add more test cases
+    }
 }

src/globe_tile_layer.rs

 use buffer::{Buffer, DrawMode};
 use cgmath::Transform;
 use context::Context;
-use coord::{LatLonRad, TileCoord, View};
+use coord::{LatLonRad, ScreenCoord, TileCoord, View};
 use map_view::MapView;
 use program::Program;
 use tile_atlas::TileAtlas;
     buffer: Buffer,
 }
 
+#[derive(Copy, Clone, Debug)]
+pub struct LatScreenEllipse {
+    pub center: ScreenCoord,
+    pub radius_x: f64,
+    pub radius_y: f64,
+    /// longitude angle in radians at center + radius_y
+    pub ref_angle: f64,
+}
+
+impl LatScreenEllipse {
+    fn new(view_center: LatLonRad, viewport_size: (u32, u32), globe_radius: f64, lat: f64) -> Self {
+        LatScreenEllipse {
+            center: ScreenCoord {
+                x: viewport_size.0 as f64 * 0.5,
+                y: viewport_size.1 as f64 * 0.5 * (lat - view_center.lat).sin() * globe_radius,
+            },
+            radius_x: lat.cos() * globe_radius,
+            radius_y: lat.cos() * -view_center.lat.sin() * globe_radius,
+            ref_angle: view_center.lon,
+        }
+    }
+}
+
 
 impl GlobeTileLayer {
     pub fn new(
                 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 = 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);

src/map_view.rs

     }
 
     //TODO Put this in a new module with other "sphere things"
+    //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_globe_tiles(&self) -> Vec<TileCoord> {
         let uzoom = self.tile_zoom();
 
         let center_tile = self.center.on_tile_at_zoom(uzoom).globe_norm();
 
+        let transform = self.globe_transformation_matrix();
+
+        let add_tile_if_visible = |tc: TileCoord, vec: &mut Vec<TileCoord>| -> bool {
+            let nearest = tc.nearest_inside_point(self.center).to_latlon_rad().to_sphere_point3();
+            let screen_coord = transform.transform_point(nearest);
+
+            let visible = screen_coord.x >= -1.0 && screen_coord.x <= 1.0 &&
+                screen_coord.y >= -1.0 && screen_coord.y <= 1.0;
+
+            if visible {
+                vec.push(tc);
+                true
+            } else {
+                false
+            }
+        };
 
         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 dx in 0..(zoom_level_tiles / 2) {
+                let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x + dx, center_tile.y), &mut tiles);
+                if !v {
+                    break;
+                }
+            }
+            for dx in 1..(1 + zoom_level_tiles / 2) {
+                let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x - dx, center_tile.y), &mut tiles);
+                if !v {
+                    break;
+                }
+            }
+
+            // move south
+            for y in (center_tile.y + 1)..zoom_level_tiles {
+                let mut visible = false;
 
-                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 dx in 0..(zoom_level_tiles / 2) {
+                    let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x + dx, y), &mut tiles);
+                    visible = visible || v;
+                    if !v {
+                        break;
+                    }
                 }
-                for y in ry1+1..ry2 {
-                    tiles.push(TileCoord::new(uzoom, rx1, y).globe_norm());
-                    tiles.push(TileCoord::new(uzoom, rx2, y).globe_norm());
+                for dx in 1..(1 + zoom_level_tiles / 2) {
+                    let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x - dx, y), &mut tiles);
+                    visible = visible || v;
+                    if !v {
+                        break;
+                    }
+                }
+
+                if !visible {
+                    break;
+                }
+            }
+
+            // move north
+            for y in (0..center_tile.y).rev() {
+                let mut visible = false;
+
+                for dx in 0..(zoom_level_tiles / 2) {
+                    let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x + dx, y), &mut tiles);
+                    visible = visible || v;
+                    if !v {
+                        break;
+                    }
+                }
+                for dx in 1..(1 + zoom_level_tiles / 2) {
+                    let v = add_tile_if_visible(TileCoord::new(uzoom, center_tile.x - dx, y), &mut tiles);
+                    visible = visible || v;
+                    if !v {
+                        break;
+                    }
+                }
+
+                if !visible {
+                    break;
                 }
             }
         }

src/map_view_gl.rs

     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(),
+            //TODO uncomment
+            //ViewMode::Globe => self.map_view.globe_covers_viewport(),
+            ViewMode::Globe => false,
         }
     }