Render the map as a sphere

A work in progress...

shader/globe_tile.frag

+#version 100
+precision mediump float;
+
+varying vec2 v_tex;
+uniform sampler2D tex_map;
+
+void main() {
+    gl_FragColor = vec4(texture2D(tex_map, v_tex.xy).rgb, 1.0);
+}

shader/globe_tile.vert

+#version 100
+precision mediump float;
+
+attribute vec3 position;
+attribute vec2 tex_coord;
+
+varying vec2 v_tex;
+
+void main() {
+    gl_Position = vec4(position.xy, 0.0, 1.0);
+    v_tex = tex_coord;
+}

src/coord.rs

-use std::f64::consts::PI;
+use std::f64::consts::{PI, FRAC_1_PI};
 use tile_source::TileSourceId;
+use cgmath::{Point3};
 
 
 /// A position in latitude, longitude.
+/// Values are in degrees and usually in these intervals:
+/// latitude: [-90.0, 90.0]
+/// longitude: [-180, 180.0]
 #[derive(Copy, Debug, PartialEq, Clone)]
 pub struct LatLon {
     pub lat: f64,
     }
 }
 
+//TODO Add more conversions from/to LatLonRad
+/// A position in latitude, longitude.
+/// Values are in radians and usually in these intervals:
+/// latitude: [-0.5 * π, 0.5 * π]
+/// longitude: [-π, π]
+#[derive(Copy, Debug, PartialEq, Clone)]
+pub struct LatLonRad {
+    pub lat: f64,
+    pub lon: f64,
+}
+
+impl LatLonRad {
+    pub fn new(lat: f64, lon: f64) -> Self {
+        LatLonRad { lat, lon }
+    }
+
+    pub fn to_sphere_xyz(&self, radius: f64) -> SphereXYZ {
+        SphereXYZ {
+            x: radius * self.lat.cos() * self.lon.cos(),
+            y: radius * self.lat.sin(),
+            z: radius * self.lat.cos() * self.lon.sin(),
+        }
+    }
+
+    pub fn to_sphere_point3(&self, radius: f64) -> Point3<f32> {
+        let p = self.to_sphere_xyz(radius);
+        Point3::new(
+            p.x as f32,
+            p.y as f32,
+            p.z as f32,
+        )
+    }
+}
+
+#[derive(Copy, Debug, PartialEq, Clone)]
+pub struct SphereXYZ {
+    pub x: f64,
+    pub y: f64,
+    pub z: f64,
+}
+
+impl SphereXYZ {
+    pub fn new(x: f64, y: f64, z: f64) -> Self {
+        SphereXYZ { x, y, z }
+    }
+}
+
 /// A position in map coordinates.
 /// Valid values for x and y lie in the interval [0.0, 1.0].
 #[derive(Copy, Debug, PartialEq, Clone)]
     fn from(pos: LatLon) -> MapCoord {
         let x = pos.lon * (1.0 / 360.0) + 0.5;
         let pi_lat = pos.lat * (PI / 180.0);
-        let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 / PI) + 0.5;
+        let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 * FRAC_1_PI) + 0.5;
 
         MapCoord { x, y }
     }
         self.y = 0.0f64.max(1.0f64.min(self.y));
     }
 
+    pub fn to_latlon_rad(&self) -> LatLonRad {
+        LatLonRad {
+            lat: (PI - self.y * (2.0 * PI)).sinh().atan(),
+            lon: self.x * (2.0 * PI) - PI,
+        }
+    }
 }
 
 /// A position on the screen in pixels. Top-left corner is (0.0, 0.0).
         MapCoord::new(f64::from(self.x) * inv_zoom_factor, f64::from(self.y) * inv_zoom_factor)
     }
 
+    // Return the LatLonRad coordinate of the top left corner of the current tile.
+    pub fn latlon_rad_north_west(&self) -> LatLonRad {
+        let factor = f64::powi(2.0, -(self.zoom as i32)) * (2.0 * PI);
+        LatLonRad::new(
+            (PI - f64::from(self.y) * factor).sinh().atan(),
+            f64::from(self.x) * factor - PI,
+        )
+    }
+
+    // Return the LatLonRad coordinate of the bottom right corner of the current tile.
+    pub fn latlon_rad_south_east(&self) -> LatLonRad {
+        TileCoord { zoom: self.zoom, x: self.x + 1, y: self.y + 1 }.latlon_rad_north_west()
+    }
+
     // Return the MapCoord of the center of the current tile.
     pub fn map_coord_center(&self) -> MapCoord {
         let inv_zoom_factor = f64::powi(2.0, -(self.zoom as i32));

src/globe_tile_layer.rs

+use std::f32::consts::{PI, FRAC_1_PI};
+use std::ffi::CStr;
+use buffer::{Buffer, DrawMode};
+use cgmath::{Matrix3, Point3, Transform, vec3};
+use context::Context;
+use coord::{LatLonRad, TileCoord, View};
+use map_view::MapView;
+use program::Program;
+use tile_atlas::TileAtlas;
+use tile_cache::TileCache;
+use tile_source::TileSource;
+use vertex_attrib::VertexAttribParams;
+
+
+#[derive(Debug)]
+pub struct GlobeTileLayer {
+    program: Program,
+    buffer: Buffer,
+}
+
+
+impl GlobeTileLayer {
+    pub fn new(
+        cx: &mut Context,
+    ) -> GlobeTileLayer
+    {
+        let buffer = Buffer::new(cx, &[], 0);
+        check_gl_errors!(cx);
+        cx.bind_buffer(buffer.id());
+
+        let mut program = Program::new(
+            cx,
+            include_bytes!("../shader/globe_tile.vert"),
+            include_bytes!("../shader/globe_tile.frag"),
+        ).unwrap();
+        check_gl_errors!(cx);
+
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"position\0").unwrap(),
+            &VertexAttribParams::new(3, 5, 0)
+        );
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(),
+            &VertexAttribParams::new(2, 5, 3)
+        );
+        check_gl_errors!(cx);
+
+        GlobeTileLayer {
+            program,
+            buffer,
+        }
+    }
+
+    // Has to be called once before one or multiple calls to `draw`.
+    pub fn prepare_draw(&mut self, cx: &mut Context, atlas: &TileAtlas) {
+        self.program.enable_vertex_attribs(cx);
+        self.program.set_vertex_attribs(cx, &self.buffer);
+        cx.set_active_texture_unit(atlas.texture().unit());
+    }
+
+    pub fn draw(
+        &mut self,
+        cx: &mut Context,
+        map_view: &MapView,
+        source: &TileSource,
+        cache: &mut TileCache,
+        tile_atlas: &mut TileAtlas,
+        viewport_size: (u32, u32),
+    ) {
+        cache.set_view_location(View {
+            source_id: source.id(),
+            zoom: map_view.tile_zoom(),
+            center: map_view.center,
+        });
+
+        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 screen_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 rot_mat = Transform::<Point3<f32>>::concat(&rot_mat_y, &rot_mat_x);
+
+        for tile_y in 0..16 {
+            for tile_x in 0..16 {
+                let tc = TileCoord::new(4, 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);
+
+                for &(tc, sub_tile_a) in &tc.children() {
+                    for &(tc, sub_tile_b) in &tc.children() {
+                        let sub_tile = sub_tile_a.subdivide(&sub_tile_b);
+
+                        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 = screen_mat.transform_point(rot_mat.transform_point(p1));
+                        let p2 = screen_mat.transform_point(rot_mat.transform_point(p2));
+                        let p3 = screen_mat.transform_point(rot_mat.transform_point(p3));
+                        let p4 = screen_mat.transform_point(rot_mat.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(&p2);
+                        vertex_data.extend(&p3);
+                        vertex_data.extend(&p1);
+                        vertex_data.extend(&p3);
+                        vertex_data.extend(&p4);
+                    }
+                }
+            }
+        }
+
+        self.buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
+        self.buffer.draw(cx, &self.program, DrawMode::Triangles);
+    }
+}

src/main.rs

 #[macro_use]
 pub mod context;
 pub mod coord;
+pub mod globe_tile_layer;
 pub mod map_view;
 pub mod map_view_gl;
 pub mod marker_layer;

src/map_view_gl.rs

 use context::Context;
 use coord::{MapCoord, ScreenCoord};
+use globe_tile_layer::GlobeTileLayer;
 use map_view::MapView;
 use marker_layer::MarkerLayer;
 use session::Session;
+use texture::{Texture, TextureFormat};
+use tile_atlas::TileAtlas;
+use tile_cache::TileCache;
 use tile_layer::TileLayer;
 use tile_source::TileSource;
 
 pub struct MapViewGl {
     map_view: MapView,
     viewport_size: (u32, u32),
+    tile_cache: TileCache,
+    tile_atlas: TileAtlas,
     tile_layer: TileLayer,
     marker_layer: MarkerLayer,
+    globe_tile_layer: GlobeTileLayer,
     last_draw_type: DrawType,
 }
 
 enum DrawType {
     Null,
     Tiles,
-    Markers
+    Markers,
+    Globe,
 }
 
 impl MapViewGl {
             map_view.zoom = MIN_ZOOM_LEVEL;
         }
 
+        let atlas_size = {
+            let default_size = 2048;
+            let max_size = cx.max_texture_size() as u32;
+            if default_size <= max_size {
+                default_size
+            } else {
+                if tile_size * 3 > max_size {
+                    error!("maximal tile size ({}) is too small", max_size);
+                }
+
+                max_size
+            }
+        };
+
+        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_layer = TileLayer::new(cx, &tile_atlas);
+
         MapViewGl {
             map_view,
             viewport_size: initial_size,
-            tile_layer: TileLayer::new(cx, move |_| update_func(), tile_size, use_network, use_async),
+            tile_cache: TileCache::new(move |_tile| update_func(), use_network),
+            tile_atlas,
+            tile_layer,
             marker_layer: MarkerLayer::new(cx),
+            globe_tile_layer: GlobeTileLayer::new(cx),
             last_draw_type: DrawType::Null,
         }
     }
     }
 
     pub fn increase_atlas_size(&mut self, cx: &mut Context) -> Result<(), ()> {
-        self.tile_layer.double_atlas_size(cx)
+        self.tile_atlas.double_texture_size(cx)
     }
 
     fn draw_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
     {
         if self.last_draw_type != DrawType::Tiles {
             self.last_draw_type = DrawType::Tiles;
-            self.tile_layer.prepare_draw(cx);
+            self.tile_layer.prepare_draw(cx, &self.tile_atlas);
         }
 
-        self.tile_layer.draw(cx, &self.map_view, source, self.viewport_size, snap_to_pixel)
+        self.tile_layer.draw(
+            cx,
+            &self.map_view,
+            source,
+            &mut self.tile_cache,
+            &mut self.tile_atlas,
+            self.viewport_size,
+            snap_to_pixel
+        )
     }
 
     fn draw_marker(&mut self, cx: &mut Context, snap_to_pixel: bool) {
         self.marker_layer.draw(cx, &self.map_view, self.viewport_size, snap_to_pixel);
     }
 
+    fn draw_globe(&mut self, cx: &mut Context, source: &TileSource) {
+        if self.last_draw_type != DrawType::Globe {
+            self.last_draw_type = DrawType::Globe;
+            self.globe_tile_layer.prepare_draw(cx, &self.tile_atlas);
+        }
+
+        self.globe_tile_layer.draw(
+            cx,
+            &self.map_view,
+            source,
+            &mut self.tile_cache,
+            &mut self.tile_atlas,
+            self.viewport_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.
             self.draw_marker(cx, snap_to_pixel);
         }
 
+        self.draw_globe(cx, source);
+
         ret
     }
 

src/tile_atlas.rs

         (tvt, None, used_slots)
     }
 
-    fn slot_to_texture_rect(&self, slot: CacheSlot) -> TextureRect {
+    pub fn slot_to_texture_rect(&self, slot: CacheSlot) -> TextureRect {
         let scale_x = f64::from(self.tile_size) / f64::from(self.texture.width());
         let scale_y = f64::from(self.tile_size) / f64::from(self.texture.height());
 

src/tile_layer.rs

 use coord::View;
 use map_view::MapView;
 use program::Program;
-use texture::{Texture, TextureFormat};
-use tile::Tile;
 use tile_atlas::TileAtlas;
 use tile_cache::TileCache;
 use tile_source::TileSource;
 pub struct TileLayer {
     program: Program,
     buffer: Buffer,
-    cache: TileCache,
-    atlas: TileAtlas,
 }
 
 
 impl TileLayer {
-    pub fn new<F>(
+    pub fn new(
         cx: &mut Context,
-        update_func: F,
-        tile_size: u32,
-        use_network: bool,
-        use_async: bool,
+        atlas: &TileAtlas,
     ) -> TileLayer
-        where F: Fn(Tile) + Sync + Send + 'static,
     {
         let buffer = Buffer::new(cx, &[], 0);
         check_gl_errors!(cx);
         ).unwrap();
         check_gl_errors!(cx);
 
-        let atlas_size = {
-            let default_size = 2048;
-            let max_size = cx.max_texture_size() as u32;
-            if default_size <= max_size {
-                default_size
-            } else {
-                if tile_size * 3 > max_size {
-                    error!("maximal tile size ({}) is too small", max_size);
-                }
-
-                max_size
-            }
-        };
-
-        let atlas_tex = Texture::empty(cx, atlas_size, atlas_size, TextureFormat::Rgb8);
-        check_gl_errors!(cx);
-
-        program.add_texture(cx, &atlas_tex, CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
+        program.add_texture(cx, atlas.texture(), CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
         check_gl_errors!(cx);
 
         program.add_attribute(
         TileLayer {
             program,
             buffer,
-            cache: TileCache::new(update_func, use_network),
-            atlas: TileAtlas::new(cx, atlas_tex, tile_size, use_async),
         }
     }
 
-    pub fn double_atlas_size(&mut self, cx: &mut Context) -> Result<(), ()> {
-        self.atlas.double_texture_size(cx)
-    }
-
     // Has to be called once before one or multiple calls to `draw`.
-    pub fn prepare_draw(&mut self, cx: &mut Context) {
+    pub fn prepare_draw(&mut self, cx: &mut Context, atlas: &TileAtlas) {
         self.program.enable_vertex_attribs(cx);
         self.program.set_vertex_attribs(cx, &self.buffer);
-        cx.set_active_texture_unit(self.atlas.texture().unit());
+        cx.set_active_texture_unit(atlas.texture().unit());
     }
 
     pub fn draw(
         cx: &mut Context,
         map_view: &MapView,
         source: &TileSource,
+        cache: &mut TileCache,
+        atlas: &mut TileAtlas,
         viewport_size: (u32, u32),
         snap_to_pixel: bool
     ) -> Result<usize, usize> {
-        self.cache.set_view_location(View {
+        cache.set_view_location(View {
             source_id: source.id(),
             zoom: map_view.tile_zoom(),
             center: map_view.center,
         let visible_tiles = map_view.visible_tiles(snap_to_pixel);
         let mut remainder = visible_tiles.as_slice();
         let mut num_draws = 0;
-        let mut max_tiles_to_use = self.cache.max_tiles();
+        let mut max_tiles_to_use = cache.max_tiles();
 
         loop {
             let (textured_visible_tiles, remainder_opt, used_tiles) = {
-                self.atlas.textured_visible_tiles(
+                atlas.textured_visible_tiles(
                     cx,
                     remainder,
                     max_tiles_to_use,
                     source,
-                    &mut self.cache,
+                    cache,
                 )
             };