Restructure modules

* Split up map_view module into
  * map_view
  * mercator_view
  * orthografic_view

shader/map_tile_border.frag

+#version 100
+precision mediump float;
+
+varying vec2 v_tex;
+varying vec4 v_tex_minmax;
+uniform sampler2D tex_map;
+
+void main() {
+    vec2 mid = 0.5 * (v_tex_minmax.zw + v_tex_minmax.xy);
+    vec2 scale = 1.0 / (v_tex_minmax.zw - v_tex_minmax.xy);
+    vec2 dist = abs((v_tex - mid) * scale);
+    float shade = 1.0 - step(0.49, max(dist.x, dist.y)) * 0.5;
+    float add = step(0.4975, max(dist.x, dist.y)) * 0.5;
+    gl_FragColor = vec4(texture2D(tex_map, clamp(v_tex.xy, v_tex_minmax.xy, v_tex_minmax.zw)).rgb * shade + vec3(add), 1.0);
+}

src/coord.rs

         }
     }
 
-    /// 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/main.rs

 #[macro_use]
 pub mod context;
 pub mod coord;
-pub mod globe_tile_layer;
+pub mod ortho_tile_layer;
 pub mod map_view;
 pub mod map_view_gl;
 pub mod marker_layer;
+pub mod mercator_view;
+pub mod orthografic_view;
 pub mod program;
 pub mod search;
 pub mod session;

src/map_view.rs

-use cgmath::{Matrix3, Point3, Transform, vec3};
-use coord::{MapCoord, ScreenCoord, ScreenRect, TileCoord};
-use std::f32::consts::{PI, FRAC_1_PI};
-use std::f64;
+use coord::MapCoord;
 
 
-/// A view of a tiled map with a rectangular viewport and a zoom.
+/// A view of a map with a rectangular viewport and a zoom.
 #[derive(Clone, Debug)]
 pub struct MapView {
     /// Width of the viewport.
     pub tile_zoom_offset: f64,
 }
 
-/// The position and size of a specific tile on the screen.
-#[derive(Clone, Debug)]
-pub struct VisibleTile {
-    pub tile: TileCoord,
-    pub rect: ScreenRect,
-}
-
 impl MapView {
     /// Constructs a new `MapView`.
     pub fn new(width: f64, height: f64, tile_size: u32, center: MapCoord, zoom: f64) -> MapView {
         }
     }
 
-    /// Constructs a new `MapView` centered at Null Island with an integer zoom that fills a screen
-    /// with the given dimensions.
-    pub fn with_filling_zoom(width: f64, height: f64, tile_size: u32) -> MapView {
-        let min_dimension = width.min(height);
-        let zoom = (min_dimension / f64::from(tile_size)).log2().ceil();
-        MapView {
-            width,
-            height,
-            tile_size,
-            center: MapCoord::new(0.5, 0.5),
-            zoom,
-            tile_zoom_offset: 0.0,
-        }
-    }
-
-    /// Returns the map coordinate that corresponds to the top-left corner of the viewport.
-    pub fn top_left_coord(&self) -> MapCoord {
-        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
-
-        let x = self.center.x + -0.5 * self.width * scale;
-        let y = self.center.y + -0.5 * self.height * scale;
-
-        MapCoord::new(x, y)
-    }
-
-    /// Returns the screen coordinate that corresponds to the given map coordinate.
-    pub fn map_to_screen_coord(&self, map_coord: MapCoord) -> ScreenCoord {
-        let scale = f64::powf(2.0, self.zoom) * f64::from(self.tile_size);
-
-        let delta_x = map_coord.x - self.center.x;
-        let delta_y = map_coord.y - self.center.y;
-
-        ScreenCoord {
-            x: 0.5 * self.width + delta_x * scale,
-            y: 0.5 * self.height + delta_y * scale,
-        }
-    }
-
-    /// Returns true if the viewport rectangle is fully inside the map.
-    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;
-        let y_bottom = self.center.y + 0.5 * self.height * scale;
-
-        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())
-    }
-
-    /// Returns a `Vec` of all tiles that are visible in the current viewport.
-    pub fn visible_tiles(&self, snap_to_pixel: bool) -> Vec<VisibleTile> {
-        let uzoom = self.tile_zoom();
-        let top_left_tile = self.top_left_coord().on_tile_at_zoom(uzoom);
-        let mut top_left_tile_screen_coord = self.tile_screen_position(&top_left_tile);
-        let tile_screen_size = f64::powf(2.0, self.zoom - f64::from(uzoom)) * f64::from(self.tile_size);
-
-        if snap_to_pixel {
-            top_left_tile_screen_coord.snap_to_pixel();
-        }
-
-        let start_tile_x = top_left_tile.x;
-        let start_tile_y = top_left_tile.y;
-        let num_tiles_x = ((self.width - top_left_tile_screen_coord.x) / tile_screen_size).ceil().max(0.0) as i32;
-        let num_tiles_y = ((self.height - top_left_tile_screen_coord.y) / tile_screen_size).ceil().max(0.0) as i32;
-
-        let mut visible_tiles = Vec::with_capacity(num_tiles_x as usize * num_tiles_y as usize);
-
-        for y in 0..num_tiles_y {
-            for x in 0..num_tiles_x {
-                let t = TileCoord::new(uzoom, start_tile_x + x, start_tile_y + y);
-                if t.is_on_planet() {
-                    visible_tiles.push(
-                        VisibleTile {
-                            tile: t,
-                            rect: ScreenRect {
-                                x: top_left_tile_screen_coord.x + tile_screen_size * f64::from(x),
-                                y: top_left_tile_screen_coord.y + tile_screen_size * f64::from(y),
-                                width: tile_screen_size,
-                                height: tile_screen_size,
-                            }
-                        }
-                    );
-                }
-            }
-        }
-
-        visible_tiles
-    }
-
-    //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();
-
-        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 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![];
-
-        {
-            let zoom_level_tiles = TileCoord::get_zoom_level_tiles(uzoom);
-
-            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 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;
-                }
-            }
-
-            // 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;
-                }
-            }
-        }
-
-        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
-    }
-
     /// Returns the tile zoom offset.
-    pub fn tile_zoom_offset(&self) -> f64 {
-        self.tile_zoom_offset
+    pub fn tile_zoom_offset(map_view: &MapView) -> f64 {
+        map_view.tile_zoom_offset
     }
 
     /// Set the tile zoom offset.
     pub fn zoom(&mut self, zoom_delta: f64) {
         self.zoom += zoom_delta;
     }
-
-    /// Change zoom value by `zoom_delta` and zoom to a position given in screen coordinates.
-    pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
-        let delta_x = pos.x - self.width * 0.5;
-        let delta_y = pos.y - self.height * 0.5;
-
-        let scale =
-            (f64::powf(2.0, -self.zoom) - f64::powf(2.0, -self.zoom - zoom_delta))
-            / f64::from(self.tile_size);
-        self.zoom += zoom_delta;
-
-        self.center.x += delta_x * scale;
-        self.center.y += delta_y * scale;
-    }
-
-    /// Set a zoom value and zoom to a `position` given in screen coordinates.
-    pub fn set_zoom_at(&mut self, pos: ScreenCoord, zoom: f64) {
-        let delta_x = pos.x - self.width * 0.5;
-        let delta_y = pos.y - self.height * 0.5;
-
-        let scale = (f64::powf(2.0, -self.zoom) - f64::powf(2.0, -zoom)) / f64::from(self.tile_size);
-        self.zoom = zoom;
-
-        self.center.x += delta_x * scale;
-        self.center.y += delta_y * scale;
-    }
-
-    /// Move the center of the viewport by (`delta_x`, `delta_y`) in screen coordinates.
-    pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
-        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
-        self.center.x += delta_x * scale;
-        self.center.y += delta_y * scale;
-    }
 }

src/map_view_gl.rs

 use context::Context;
 use coord::{MapCoord, ScreenCoord};
-use globe_tile_layer::GlobeTileLayer;
+use ortho_tile_layer::OrthoTileLayer;
 use map_view::MapView;
 use marker_layer::MarkerLayer;
+use mercator_view::MercatorView;
+use orthografic_view::OrthograficView;
 use session::Session;
 use texture::{Texture, TextureFormat};
 use tile_atlas::TileAtlas;
     tile_atlas: TileAtlas,
     tile_layer: TileLayer,
     marker_layer: MarkerLayer,
-    globe_tile_layer: GlobeTileLayer,
+    ortho_tile_layer: OrthoTileLayer,
     projection: Projection,
     last_draw_type: DrawType,
 }
     Null,
     Tiles,
     Markers,
-    Globe,
+    OrthoTiles,
 }
 
 impl MapViewGl {
     {
         let tile_size = 256;
 
-        let mut map_view = MapView::with_filling_zoom(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
+        let mut map_view = MercatorView::initial_map_view(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
 
         if map_view.zoom < MIN_ZOOM_LEVEL {
             map_view.zoom = MIN_ZOOM_LEVEL;
             tile_atlas,
             tile_layer,
             marker_layer: MarkerLayer::new(cx),
-            globe_tile_layer: GlobeTileLayer::new(cx),
+            ortho_tile_layer: OrthoTileLayer::new(cx),
             projection: Projection::Mercator,
             last_draw_type: DrawType::Null,
         }
 
     pub fn map_covers_viewport(&self) -> bool {
         match self.projection {
-            Projection::Mercator => self.map_view.map_covers_viewport(),
+            Projection::Mercator => MercatorView::covers_viewport(&self.map_view),
             //TODO uncomment
-            //Projection::Orthografic => self.map_view.globe_covers_viewport(),
+            //Projection::Orthografic => OrthograficView::covers_viewport(&self.map_view),
             Projection::Orthografic => false,
         }
     }
         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);
+    fn draw_ortho_tiles(&mut self, cx: &mut Context, source: &TileSource) {
+        if self.last_draw_type != DrawType::OrthoTiles {
+            self.last_draw_type = DrawType::OrthoTiles;
+            self.ortho_tile_layer.prepare_draw(cx, &self.tile_atlas);
         }
 
-        self.globe_tile_layer.draw(
+        self.ortho_tile_layer.draw(
             cx,
             &self.map_view,
             source,
                 ret
             },
             Projection::Orthografic => {
-                self.draw_globe(cx, source);
+                self.draw_ortho_tiles(cx, source);
                 Ok(1)
             },
         }
     }
 
     pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
+        //TODO implement for OrthograficView
         if self.map_view.zoom + zoom_delta < MIN_ZOOM_LEVEL {
-            self.map_view.set_zoom_at(pos, MIN_ZOOM_LEVEL);
+            MercatorView::set_zoom_at(&mut self.map_view, pos, MIN_ZOOM_LEVEL);
         } else if self.map_view.zoom + zoom_delta > MAX_ZOOM_LEVEL {
-            self.map_view.set_zoom_at(pos, MAX_ZOOM_LEVEL);
+            MercatorView::set_zoom_at(&mut self.map_view, pos, MAX_ZOOM_LEVEL);
         } else {
-            self.map_view.zoom_at(pos, zoom_delta);
+            MercatorView::zoom_at(&mut self.map_view, pos, zoom_delta);
         }
         self.map_view.center.normalize_xy();
     }
 
     pub fn change_tile_zoom_offset(&mut self, delta_offset: f64) {
-        let offset = self.map_view.tile_zoom_offset();
+        let offset = self.map_view.tile_zoom_offset;
         self.map_view.set_tile_zoom_offset(offset + delta_offset);
     }
 
     pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
-        self.map_view.move_pixel(delta_x, delta_y);
+        //TODO implement for OrthograficView
+        MercatorView::move_pixel(&mut self.map_view, delta_x, delta_y);
         self.map_view.center.normalize_xy();
     }
 

src/marker_layer.rs

 use coord::{MapCoord, ScreenRect};
 use image;
 use map_view::MapView;
+use mercator_view::MercatorView;
 use program::Program;
 use texture::Texture;
 use vertex_attrib::VertexAttribParams;
 
         for map_pos in &self.positions {
             let screen_pos = {
-                let mut sp = map_view.map_to_screen_coord(*map_pos);
+                let mut sp = MercatorView::map_to_screen_coord(map_view, *map_pos);
                 if snap_to_pixel {
-                    let topleft = map_view.map_to_screen_coord(MapCoord::new(0.0, 0.0));
+                    let topleft = MercatorView::map_to_screen_coord(map_view, MapCoord::new(0.0, 0.0));
                     let mut snapped = topleft;
                     snapped.snap_to_pixel();
 

src/mercator_view.rs

+use coord::{MapCoord, ScreenCoord, ScreenRect, TileCoord};
+use map_view::MapView;
+
+
+/// A view of a tiled map with a rectangular viewport and a zoom.
+#[derive(Clone, Debug)]
+pub struct MercatorView {
+}
+
+/// The position and size of a specific tile on the screen.
+#[derive(Clone, Debug)]
+pub struct VisibleTile {
+    pub tile: TileCoord,
+    pub rect: ScreenRect,
+}
+
+impl MercatorView {
+    /// Constructs a `MapView` centered at Null Island with an integer zoom that fills a screen
+    /// with the given dimensions.
+    pub fn initial_map_view(width: f64, height: f64, tile_size: u32) -> MapView {
+        let min_dimension = width.min(height);
+        let zoom = (min_dimension / f64::from(tile_size)).log2().ceil();
+        MapView {
+            width,
+            height,
+            tile_size,
+            center: MapCoord::new(0.5, 0.5),
+            zoom,
+            tile_zoom_offset: 0.0,
+        }
+    }
+
+    /// Returns the map coordinate that corresponds to the top-left corner of the viewport.
+    pub fn top_left_coord(map_view: &MapView) -> MapCoord {
+        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+
+        let x = map_view.center.x + -0.5 * map_view.width * scale;
+        let y = map_view.center.y + -0.5 * map_view.height * scale;
+
+        MapCoord::new(x, y)
+    }
+
+    /// Returns the screen coordinate that corresponds to the given map coordinate.
+    pub fn map_to_screen_coord(map_view: &MapView, map_coord: MapCoord) -> ScreenCoord {
+        let scale = f64::powf(2.0, map_view.zoom) * f64::from(map_view.tile_size);
+
+        let delta_x = map_coord.x - map_view.center.x;
+        let delta_y = map_coord.y - map_view.center.y;
+
+        ScreenCoord {
+            x: 0.5 * map_view.width + delta_x * scale,
+            y: 0.5 * map_view.height + delta_y * scale,
+        }
+    }
+
+    /// Returns true if the viewport rectangle is fully inside the map.
+    pub fn covers_viewport(map_view: &MapView) -> bool {
+        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+
+        let y_top = map_view.center.y + -0.5 * map_view.height * scale;
+        let y_bottom = map_view.center.y + 0.5 * map_view.height * scale;
+
+        y_top >= 0.0 && y_bottom <= 1.0
+    }
+
+    /// Returns the screen coordinate of the top-left corner of a tile.
+    pub fn tile_screen_position(map_view: &MapView, tile: &TileCoord) -> ScreenCoord {
+        Self::map_to_screen_coord(map_view, tile.map_coord_north_west())
+    }
+
+    /// Returns a `Vec` of all tiles that are visible in the current viewport.
+    pub fn visible_tiles(map_view: &MapView, snap_to_pixel: bool) -> Vec<VisibleTile> {
+        let uzoom = Self::tile_zoom(map_view);
+        let top_left_tile = Self::top_left_coord(map_view).on_tile_at_zoom(uzoom);
+        let mut top_left_tile_screen_coord = Self::tile_screen_position(map_view, &top_left_tile);
+        let tile_screen_size = f64::powf(2.0, map_view.zoom - f64::from(uzoom)) *
+            f64::from(map_view.tile_size);
+
+        if snap_to_pixel {
+            top_left_tile_screen_coord.snap_to_pixel();
+        }
+
+        let start_tile_x = top_left_tile.x;
+        let start_tile_y = top_left_tile.y;
+        let num_tiles_x = ((map_view.width - top_left_tile_screen_coord.x) /
+                           tile_screen_size).ceil().max(0.0) as i32;
+        let num_tiles_y = ((map_view.height - top_left_tile_screen_coord.y) /
+                           tile_screen_size).ceil().max(0.0) as i32;
+
+        let mut visible_tiles = Vec::with_capacity(num_tiles_x as usize * num_tiles_y as usize);
+
+        for y in 0..num_tiles_y {
+            for x in 0..num_tiles_x {
+                let t = TileCoord::new(uzoom, start_tile_x + x, start_tile_y + y);
+                if t.is_on_planet() {
+                    visible_tiles.push(
+                        VisibleTile {
+                            tile: t,
+                            rect: ScreenRect {
+                                x: top_left_tile_screen_coord.x + tile_screen_size * f64::from(x),
+                                y: top_left_tile_screen_coord.y + tile_screen_size * f64::from(y),
+                                width: tile_screen_size,
+                                height: tile_screen_size,
+                            }
+                        }
+                    );
+                }
+            }
+        }
+
+        visible_tiles
+    }
+
+    /// Returns the tile zoom value that is used for rendering with the current zoom.
+    pub fn tile_zoom(map_view: &MapView) -> u32 {
+        (map_view.zoom + map_view.tile_zoom_offset).floor().max(0.0) as u32
+    }
+
+    /// Change zoom value by `zoom_delta` and zoom to a position given in screen coordinates.
+    pub fn zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom_delta: f64) {
+        let delta_x = pos.x - map_view.width * 0.5;
+        let delta_y = pos.y - map_view.height * 0.5;
+
+        let scale = (f64::powf(2.0, -map_view.zoom) - f64::powf(2.0, -map_view.zoom - zoom_delta))
+            / f64::from(map_view.tile_size);
+
+        map_view.zoom += zoom_delta;
+        map_view.center.x += delta_x * scale;
+        map_view.center.y += delta_y * scale;
+    }
+
+    /// Set a zoom value and zoom to a `position` given in screen coordinates.
+    pub fn set_zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom: f64) {
+        let delta_x = pos.x - map_view.width * 0.5;
+        let delta_y = pos.y - map_view.height * 0.5;
+
+        let scale = (f64::powf(2.0, -map_view.zoom) - f64::powf(2.0, -zoom)) /
+            f64::from(map_view.tile_size);
+
+        map_view.zoom = zoom;
+        map_view.center.x += delta_x * scale;
+        map_view.center.y += delta_y * scale;
+    }
+
+    /// Move the center of the viewport by (`delta_x`, `delta_y`) in screen coordinates.
+    pub fn move_pixel(map_view: &mut MapView, delta_x: f64, delta_y: f64) {
+        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+        map_view.center.x += delta_x * scale;
+        map_view.center.y += delta_y * scale;
+    }
+}

src/globe_tile_layer.rs → src/ortho_tile_layer.rs

-use std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
 use cgmath::Transform;
 use context::Context;
 use coord::{LatLonRad, ScreenCoord, TileCoord, View};
 use map_view::MapView;
+use orthografic_view::OrthograficView;
 use program::Program;
+use std::ffi::CStr;
 use tile_atlas::TileAtlas;
 use tile_cache::TileCache;
 use tile_source::TileSource;
 
 
 #[derive(Debug)]
-pub struct GlobeTileLayer {
+pub struct OrthoTileLayer {
     program: Program,
     buffer: Buffer,
 }
 }
 
 impl LatScreenEllipse {
-    fn new(view_center: LatLonRad, viewport_size: (u32, u32), globe_radius: f64, lat: f64) -> Self {
+    fn new(view_center: LatLonRad, viewport_size: (u32, u32), sphere_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,
+                y: viewport_size.1 as f64 * 0.5 * (lat - view_center.lat).sin() * sphere_radius,
             },
-            radius_x: lat.cos() * globe_radius,
-            radius_y: lat.cos() * -view_center.lat.sin() * globe_radius,
+            radius_x: lat.cos() * sphere_radius,
+            radius_y: lat.cos() * -view_center.lat.sin() * sphere_radius,
             ref_angle: view_center.lon,
         }
     }
 }
 
 
-impl GlobeTileLayer {
+impl OrthoTileLayer {
     pub fn new(
         cx: &mut Context,
-    ) -> GlobeTileLayer
+    ) -> OrthoTileLayer
     {
         let buffer = Buffer::new(cx, &[], 0);
         check_gl_errors!(cx);
 
         let mut program = Program::new(
             cx,
-            include_bytes!("../shader/globe_tile.vert"),
-            include_bytes!("../shader/globe_tile.frag"),
+            include_bytes!("../shader/ortho_tile.vert"),
+            include_bytes!("../shader/ortho_tile.frag"),
         ).unwrap();
         check_gl_errors!(cx);
 
         );
         check_gl_errors!(cx);
 
-        GlobeTileLayer {
+        OrthoTileLayer {
             program,
             buffer,
         }
         //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(),
+            zoom: OrthograficView::tile_zoom(map_view),
             center: map_view.center,
         });
 
         let mut vertex_data = vec![];
 
-        let transform = map_view.globe_transformation_matrix();
+        let transform = OrthograficView::transformation_matrix(map_view);
 
         let (inset_x, inset_y) = tile_atlas.texture_margins();
 
-        for tile_coord in map_view.visible_globe_tiles().into_iter() {
+        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);

src/orthografic_view.rs

+use cgmath::{Matrix3, Point3, Transform, vec3};
+use coord::TileCoord;
+use map_view::MapView;
+use std::f32::consts::{PI, FRAC_1_PI};
+use std::f64;
+
+
+#[derive(Clone, Debug)]
+pub struct OrthograficView {
+}
+
+impl OrthograficView {
+    /// Returns true if the rendering covers the whole viewport.
+    pub fn covers_viewport(map_view: &MapView) -> 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 sphere_diameter = 2.0f64.powf(map_view.zoom) *
+            (f64::consts::FRAC_1_PI * map_view.tile_size as f64);
+
+        return map_view.width.hypot(map_view.height) < sphere_diameter;
+    }
+
+    /// Returns the tile zoom value that is used for rendering with the current zoom.
+    //TODO Insert real implementation. Add TileCoord parameter -> lower resolution at the poles
+    pub fn tile_zoom(map_view: &MapView) -> u32 {
+        (map_view.zoom + map_view.tile_zoom_offset).floor().max(0.0) as u32
+    }
+
+    //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> {
+        let uzoom = Self::tile_zoom(map_view);
+
+        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 = map_view.center.on_tile_at_zoom(uzoom).globe_norm();
+
+        let transform = Self::transformation_matrix(map_view);
+
+        let add_tile_if_visible = |tc: TileCoord, vec: &mut Vec<TileCoord>| -> bool {
+            let test_point = tc.latlon_rad_north_west().to_sphere_point3();
+            let test_point = transform.transform_point(test_point);
+
+            let visible = test_point.x >= -1.0 && test_point.x <= 1.0 &&
+                test_point.y >= -1.0 && test_point.y <= 1.0;
+
+            if visible {
+                vec.push(tc);
+                true
+            } else {
+                false
+            }
+        };
+
+        let mut tiles = vec![];
+
+        {
+            let zoom_level_tiles = TileCoord::get_zoom_level_tiles(uzoom);
+
+            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 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;
+                }
+            }
+
+            // 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;
+                }
+            }
+        }
+
+        tiles
+    }
+
+    pub fn transformation_matrix(map_view: &MapView) -> Matrix3<f32> {
+        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 / map_view.width as f32, factor / map_view.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 = 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);
+        transform
+    }
+}

src/tile_atlas.rs

 use coord::{ScreenRect, SubTileCoord, TileCoord, TextureRect};
 use image;
 use linked_hash_map::LinkedHashMap;
-use map_view::VisibleTile;
+use mercator_view::VisibleTile;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use texture::Texture;

src/tile_layer.rs

 use context::Context;
 use coord::View;
 use map_view::MapView;
+use mercator_view::MercatorView;
 use program::Program;
 use tile_atlas::TileAtlas;
 use tile_cache::TileCache;
     ) -> Result<usize, usize> {
         cache.set_view_location(View {
             source_id: source.id(),
-            zoom: map_view.tile_zoom(),
+            zoom: MercatorView::tile_zoom(map_view),
             center: map_view.center,
         });
 
-        let visible_tiles = map_view.visible_tiles(snap_to_pixel);
+        let visible_tiles = MercatorView::visible_tiles(map_view, snap_to_pixel);
         let mut remainder = visible_tiles.as_slice();
         let mut num_draws = 0;
         let mut max_tiles_to_use = cache.max_tiles();