Initial commit :>

Started 2015

.gitignore

@@ -0,0 +1,2 @@
+target
+.*.swp

Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "deltamap"
+version = "0.1.0"
+authors = ["Johannes Hofmann <mail@b-r-u.org>"]
+
+[dependencies]
+gl = "0.7"
+image = "0.18"
+linked-hash-map = "0.5.0"
+osmpbf = "0.1"
+servo-glutin = "0.13"
+serde = "1.0"
+serde_derive = "1.0"
+reqwest = "0.8"
+toml = "0.4"
+
+[build-dependencies]
+gl_generator = "0.7"

README.md

@@ -0,0 +1,3 @@
+deltamap
+========
+A simple map viewer.

build.rs

@@ -0,0 +1,16 @@
+extern crate gl_generator;
+
+use gl_generator::{Registry, Api, Profile, Fallbacks};
+use std::env;
+use std::fs::File;
+use std::path::PathBuf;
+
+fn main() {
+    let dest = PathBuf::from(&env::var("OUT_DIR").unwrap());
+
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let mut file = File::create(&dest.join("gles_bindings.rs")).unwrap();
+    Registry::new(Api::Gles2, (3, 0), Profile::Core, Fallbacks::All, [])
+            .write_bindings(gl_generator::StructGenerator, &mut file).unwrap();
+}

deltamap.toml

@@ -0,0 +1,5 @@
+tile_cache_dir = "/tmp"
+
+[sources.OSM]
+max_zoom = 19
+url_template = "http://a.tile.openstreetmap.org/{z}/{x}/{y}.png"

shader/map.frag

@@ -0,0 +1,10 @@
+#version 100
+precision mediump float;
+
+varying vec2 v_tex;
+varying vec4 v_tex_minmax;
+uniform sampler2D tex_map;
+
+void main() {
+    gl_FragColor = vec4(texture2D(tex_map, clamp(v_tex.xy, v_tex_minmax.xy, v_tex_minmax.zw)).rgb, 1.0);
+}

shader/map.vert

@@ -0,0 +1,15 @@
+#version 100
+precision mediump float;
+
+attribute vec2 position;
+attribute vec2 tex_coord;
+attribute vec4 tex_minmax;
+
+varying vec2 v_tex;
+varying vec4 v_tex_minmax;
+
+void main() {
+    gl_Position = vec4(position, 0.0, 1.0);
+    v_tex = tex_coord;
+    v_tex_minmax = tex_minmax;
+}

src/buffer.rs

@@ -0,0 +1,82 @@
+use ::context;
+use context::Context;
+use std::mem;
+
+
+#[derive(Clone, Debug)]
+pub struct Buffer<'a> {
+    cx: &'a Context,
+    buffer_obj: u32,
+    num_elements: usize,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum DrawMode {
+    Triangles,
+    TriangleStrip,
+    TriangleFan,
+}
+
+impl DrawMode {
+    pub fn to_gl_enum(self) -> u32 {
+        match self {
+            DrawMode::Triangles => context::gl::TRIANGLES,
+            DrawMode::TriangleStrip => context::gl::TRIANGLE_STRIP,
+            DrawMode::TriangleFan => context::gl::TRIANGLE_FAN,
+        }
+    }
+}
+
+impl<'a> Buffer<'a> {
+    pub fn new(cx: &'a Context, vertex_data: &[f32], num_elements: usize) -> Buffer<'a> {
+        let mut buffer_obj = 0_u32;
+
+        unsafe {
+            cx.gl.GenBuffers(1, &mut buffer_obj);
+            cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, buffer_obj);
+            cx.gl.BufferData(context::gl::ARRAY_BUFFER,
+                             (vertex_data.len() * mem::size_of::<f32>()) as context::gl::types::GLsizeiptr,
+                             vertex_data.as_ptr() as *const _,
+                             context::gl::STATIC_DRAW);
+
+            //TODO call this only once
+            // VAOs are not OpenGL ES 2.0 compatible, but are required for rendering with a core context.
+            if cx.gl.BindVertexArray.is_loaded() {
+                let mut vao = mem::uninitialized();
+                cx.gl.GenVertexArrays(1, &mut vao);
+                cx.gl.BindVertexArray(vao);
+            }
+        }
+
+        Buffer {
+            cx: cx,
+            buffer_obj: buffer_obj,
+            num_elements: num_elements,
+        }
+    }
+
+    pub fn set_data(&mut self, vertex_data: &[f32], num_elements: usize) {
+        unsafe {
+            self.cx.gl.BufferData(context::gl::ARRAY_BUFFER,
+                                  (vertex_data.len() * mem::size_of::<f32>()) as context::gl::types::GLsizeiptr,
+                                  vertex_data.as_ptr() as *const _,
+                                  context::gl::DYNAMIC_DRAW);
+        }
+        self.num_elements = num_elements;
+    }
+
+    pub fn bind(&self) {
+        unsafe {
+            self.cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, self.buffer_obj);
+        }
+    }
+
+    pub fn draw(&self, mode: DrawMode) {
+        unsafe {
+            self.cx.gl.DrawArrays(
+                mode.to_gl_enum(),
+                0,
+                self.num_elements as context::gl::types::GLsizei);
+        }
+    }
+}

src/config.rs

@@ -0,0 +1,58 @@
+use serde_derive;
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use tile_source::TileSource;
+use toml;
+
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct Config {
+    tile_cache_dir: String,
+    sources: BTreeMap<String, Source>,
+}
+
+#[derive(Deserialize, Clone, Debug)]
+struct Source {
+    max_zoom: u32,
+    url_template: String,
+}
+
+impl Config {
+    pub fn from_toml<P: AsRef<Path>>(path: P) -> Option<Config> {
+        let mut file = match File::open(path) {
+            Ok(file) => file,
+            Err(_) => return None,
+        };
+
+        let mut content = String::new();
+        if file.read_to_string(&mut content).is_err() {
+            return None;
+        }
+
+        toml::from_str(&content).ok()
+    }
+
+    pub fn tile_sources(&self) -> BTreeMap<String, TileSource> {
+        let mut map = BTreeMap::new();
+
+        for (id, (name, source)) in self.sources.iter().enumerate() {
+            let mut path = PathBuf::from(&self.tile_cache_dir);
+            //TODO escape name (no slashes or dots)
+            path.push(name);
+
+            map.insert(
+                name.clone(),
+                TileSource::new(
+                    id as u32,
+                    source.url_template.clone(),
+                    path,
+                    source.max_zoom,
+                ),
+            );
+        }
+
+        return map;
+    }
+}

src/context.rs

@@ -0,0 +1,83 @@
+use glutin;
+
+pub(crate) mod gl {
+    pub use self::Gles2 as Gl;
+    include!(concat!(env!("OUT_DIR"), "/gles_bindings.rs"));
+}
+
+#[derive(Clone)]
+pub struct Context {
+    pub(crate) gl: gl::Gl,
+}
+
+impl ::std::fmt::Debug for Context {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        let version = unsafe {
+            let data = ::std::ffi::CStr::from_ptr(self.gl.GetString(gl::VERSION) as *const _).to_bytes().to_vec();
+            String::from_utf8(data).unwrap_or_else(|_| "".into())
+        };
+        write!(f, "Context {{ version: {:?} }}", version)
+    }
+}
+
+macro_rules! check_gl_errors {
+    ($cx:expr) => (
+        $cx.check_errors(file!(), line!());
+    )
+}
+
+impl Context {
+    pub fn from_window(window: &glutin::Window) -> Context {
+        let gl = gl::Gl::load_with(|ptr| window.get_proc_address(ptr) as *const _);
+
+        Context {gl: gl}
+    }
+
+    pub fn gl_version(&self) -> String {
+        unsafe {
+            let data = ::std::ffi::CStr::from_ptr(self.gl.GetString(gl::VERSION) as *const _).to_bytes().to_vec();
+            String::from_utf8(data).unwrap_or_else(|_| "".into())
+        }
+    }
+
+    pub fn max_texture_size(&self) -> i32 {
+        unsafe {
+            let mut size = 0;
+            self.gl.GetIntegerv(gl::MAX_TEXTURE_SIZE, &mut size as *mut _);
+            size
+        }
+    }
+
+    pub unsafe fn check_errors(&self, file: &str, line: u32) {
+        loop {
+            match self.gl.GetError() {
+                gl::NO_ERROR => break,
+                gl::INVALID_VALUE => {
+                    println!("{}:{}, invalid value error", file, line);
+                },
+                gl::INVALID_ENUM => {
+                    println!("{}:{}, invalid enum error", file, line);
+                },
+                gl::INVALID_OPERATION => {
+                    println!("{}:{}, invalid operation error", file, line);
+                },
+                gl::INVALID_FRAMEBUFFER_OPERATION => {
+                    println!("{}:{}, invalid framebuffer operation error", file, line);
+                },
+                gl::OUT_OF_MEMORY => {
+                    println!("{}:{}, out of memory error", file, line);
+                },
+                x => {
+                    println!("{}:{}, unknown error {}", file, line, x);
+                },
+            }
+        }
+    }
+
+    pub fn clear_color(&self, color: (f32, f32, f32, f32)) {
+        unsafe {
+            self.gl.ClearColor(color.0, color.1, color.2, color.3);
+            self.gl.Clear(gl::COLOR_BUFFER_BIT);
+        }
+    }
+}

src/coord.rs

@@ -0,0 +1,104 @@
+use std::f64::consts::PI;
+use tile::Tile;
+
+/// A position in map coordinates.
+/// Valid values for x and y lie in the interval [0.0, 1.0].
+#[derive(Copy, Debug, PartialEq, Clone)]
+pub struct MapCoord {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl MapCoord {
+    pub fn new(x: f64, y: f64) -> MapCoord {
+        MapCoord {
+            x: x,
+            y: y,
+        }
+    }
+
+    pub fn from_latlon(latitude: f64, longitude: f64) -> MapCoord {
+        let x = longitude * (1.0 / 360.0) + 0.5;
+        let pi_lat = latitude * (PI / 180.0);
+        let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 / PI) + 0.5;
+
+        MapCoord {
+            x: x,
+            y: y,
+        }
+    }
+
+    //TODO differ between normalized and not normalized tiles
+    pub fn on_tile_at_zoom(&self, zoom: u32) -> Tile {
+        let zoom_factor = f64::powi(2.0, zoom as i32);
+        let ix = (self.x * zoom_factor).floor() as i32;
+        let iy = (self.y * zoom_factor).floor() as i32;
+
+        let x = ix;
+        let y = iy;
+
+        Tile {
+            zoom: zoom,
+            tile_x: x,
+            tile_y: y,
+        }
+    }
+
+    pub fn normalize_x(&mut self) {
+        // Wrap around in x-direction.
+        // Do not wrap around in y-direction. The poles don't touch.
+        self.x = (self.x.fract() + 1.0).fract();
+    }
+
+    pub fn normalize_xy(&mut self) {
+        // Wrap around in x-direction.
+        // Restrict y coordinates to interval [0.0, 1.0]
+        self.x = (self.x.fract() + 1.0).fract();
+        self.y = 0.0f64.max(1.0f64.min(self.y));
+    }
+
+}
+
+#[test]
+fn test_normalize() {
+    {
+        let a = MapCoord::new(0.0, 0.0);
+        let mut b = a.clone();
+        assert_eq!(a, b);
+        b.normalize_x();
+        assert_eq!(a, b);
+    }
+    {
+        let mut a = MapCoord::new(1.0, 1.0);
+        let b = MapCoord::new(0.0, 1.0);
+        a.normalize_x();
+        assert_eq!(a, b);
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct ScreenCoord {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl ScreenCoord {
+    pub fn new(x: f64, y: f64) -> Self {
+        ScreenCoord {
+            x: x,
+            y: y,
+        }
+    }
+    pub fn snap_to_pixel(&mut self) {
+        self.x = self.x.floor();
+        self.y = self.y.floor();
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct ScreenRect {
+    pub x: f64,
+    pub y: f64,
+    pub width: f64,
+    pub height: f64,
+}

src/main.rs

@@ -0,0 +1,244 @@
+#[cfg(target_os = "android")]
+#[macro_use]
+extern crate android_glue;
+
+#[macro_use]
+extern crate serde_derive;
+
+extern crate glutin;
+extern crate image;
+extern crate linked_hash_map;
+extern crate reqwest;
+extern crate serde;
+extern crate toml;
+
+
+#[macro_use]
+mod context;
+
+mod buffer;
+mod config;
+mod coord;
+mod map_view;
+mod map_view_gl;
+mod program;
+mod texture;
+mod tile;
+mod tile_cache;
+mod tile_cache_gl;
+mod tile_loader;
+mod tile_source;
+
+use coord::ScreenCoord;
+use glutin::{ElementState, Event, MouseButton, MouseScrollDelta, VirtualKeyCode};
+use map_view_gl::MapViewGl;
+use tile_source::TileSource;
+use std::time::{Duration, Instant};
+
+#[cfg(target_os = "android")]
+android_start!(main);
+
+fn resize_callback(width: u32, height: u32) {
+    println!("Window resized to {}x{}", width, height);
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum Action {
+    Nothing,
+    Redraw,
+    Close,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+struct InputState {
+    mouse_position: (i32, i32),
+    mouse_pressed: bool,
+}
+
+fn handle_event(event: Event, map: &mut MapViewGl, input_state: &mut InputState) -> Action {
+    match event {
+        Event::Closed => Action::Close,
+        Event::Awakened => Action::Redraw,
+        Event::MouseInput(ElementState::Pressed, MouseButton::Left, position) => {
+            input_state.mouse_pressed = true;
+            if let Some(p) = position {
+                input_state.mouse_position = p;
+            }
+            Action::Nothing
+        },
+        Event::MouseInput(ElementState::Released, MouseButton::Left, position) => {
+            input_state.mouse_pressed = false;
+            if let Some(p) = position {
+                input_state.mouse_position = p;
+            }
+            Action::Nothing
+        },
+        Event::MouseMoved(x, y) => {
+            if input_state.mouse_pressed {
+                map.move_pixel(
+                    f64::from(input_state.mouse_position.0 - x),
+                    f64::from(input_state.mouse_position.1 - y),
+                );
+                input_state.mouse_position = (x, y);
+                Action::Redraw
+            } else {
+                input_state.mouse_position = (x, y);
+                Action::Nothing
+            }
+        },
+        Event::MouseWheel(delta, _, position) => {
+            let (dx, dy) = match delta {
+                MouseScrollDelta::LineDelta(dx, dy) => {
+                    // filter strange wheel events with huge values.
+                    // (maybe this is just a personal touchpad driver issue)
+                    if dx.abs() < 16.0 && dy.abs() < 16.0 {
+                        (dx, dy * 10.0)
+                    } else {
+                        (0.0, 0.0)
+                    }
+                },
+                MouseScrollDelta::PixelDelta(dx, dy) => (dx, dy),
+            };
+            if let Some(p) = position {
+                input_state.mouse_position = p;
+            }
+            //TODO option to move or zoom on mouse wheel event
+            //map.move_pixel(-dx as f64, -dy as f64);
+
+            map.zoom_at(
+                ScreenCoord::new(
+                    f64::from(input_state.mouse_position.0),
+                    f64::from(input_state.mouse_position.1),
+                ),
+                f64::from(dy) * 0.0125,
+            );
+            Action::Redraw
+        },
+        Event::KeyboardInput(glutin::ElementState::Pressed, _, Some(keycode)) => {
+            match keycode {
+                VirtualKeyCode::Escape => {
+                    Action::Close
+                },
+                VirtualKeyCode::Left => {
+                    map.move_pixel(-50.0, 0.0);
+                    Action::Redraw
+                },
+                VirtualKeyCode::Right => {
+                    map.move_pixel(50.0, 0.0);
+                    Action::Redraw
+                },
+                VirtualKeyCode::Up => {
+                    map.move_pixel(0.0, -50.0);
+                    Action::Redraw
+                },
+                VirtualKeyCode::Down => {
+                    map.move_pixel(0.0, 50.0);
+                    Action::Redraw
+                },
+                VirtualKeyCode::Add => {
+                    map.zoom(0.25);
+                    Action::Redraw
+                },
+                VirtualKeyCode::Subtract => {
+                    map.zoom(-0.25);
+                    Action::Redraw
+                },
+                _ => Action::Nothing,
+            }
+        },
+        Event::Refresh => {
+            Action::Redraw
+        },
+        Event::Resized(w, h) => {
+            map.set_viewport_size(w, h);
+            Action::Redraw
+        },
+        _ => Action::Nothing,
+    }
+}
+
+fn main() {
+    let config = config::Config::from_toml("deltamap.toml").unwrap();
+
+    let mut window = glutin::WindowBuilder::new().build().unwrap();
+    window.set_title("DeltaMap");
+    window.set_window_resize_callback(Some(resize_callback as fn(u32, u32)));
+    let _ = unsafe { window.make_current() };
+
+    let proxy = window.create_window_proxy();
+
+    let cx = context::Context::from_window(&window);
+    let mut sources = config.tile_sources();
+    let mut map = map_view_gl::MapViewGl::new(
+        &cx,
+        sources.into_iter().next().unwrap().1,
+        window.get_inner_size_pixels().unwrap(),
+        move || { proxy.wakeup_event_loop(); },
+    );
+
+    let mut input_state = InputState {
+        mouse_position: (0, 0),
+        mouse_pressed: false,
+    };
+
+    let milli16 = Duration::from_millis(16);
+    let mut draw_dur = Duration::from_millis(8);
+    let mut last_draw = Instant::now();
+
+    'outer: for event in window.wait_events() {
+        let mut start_loop = Instant::now();
+
+        let mut redraw = false;
+
+        match handle_event(event, &mut map, &mut input_state) {
+            Action::Close => break 'outer,
+            Action::Redraw => {
+                redraw = true;
+            },
+            Action::Nothing => {},
+        }
+
+        for event in window.poll_events() {
+            match handle_event(event, &mut map, &mut input_state) {
+                Action::Close => break 'outer,
+                Action::Redraw => {
+                    redraw = true;
+                },
+                Action::Nothing => {},
+            }
+        }
+
+        {
+            let diff = last_draw.elapsed();
+            if diff + draw_dur * 2 < milli16 {
+                if let Some(dur) = milli16.checked_sub(draw_dur * 2) {
+                    std::thread::sleep(dur);
+                    println!("SLEEP {}", dur.as_secs() as f64 + dur.subsec_nanos() as f64 * 1e-9);
+
+                    for event in window.poll_events() {
+                        match handle_event(event, &mut map, &mut input_state) {
+                            Action::Close => break 'outer,
+                            Action::Redraw => {
+                                redraw = true;
+                            },
+                            Action::Nothing => {},
+                        }
+                    }
+                }
+            }
+        }
+
+        if redraw {
+            let draw_start = Instant::now();
+            map.draw();
+            draw_dur = draw_start.elapsed();
+
+            let _ = window.swap_buffers();
+
+            last_draw = Instant::now();
+
+            let diff = start_loop.elapsed();
+            println!("EVENT LOOP SECS {}", diff.as_secs() as f64 + diff.subsec_nanos() as f64 * 1e-9);
+        }
+    }
+}

src/map_view.rs

@@ -0,0 +1,137 @@
+use coord::{MapCoord, ScreenCoord, ScreenRect};
+use tile::Tile;
+
+
+#[derive(Clone, Debug)]
+pub struct MapView {
+    pub width: f64,
+    pub height: f64,
+    pub tile_size: u32,
+    pub center: MapCoord,
+    pub zoom2: f64,
+}
+
+#[derive(Clone, Debug)]
+pub struct VisibleTile {
+    pub tile: Tile,
+    pub rect: ScreenRect,
+}
+
+impl MapView {
+    pub fn new(width: f64, height: f64, tile_size: u32) -> MapView {
+        MapView {
+            width: width,
+            height: height,
+            tile_size: tile_size,
+            center: MapCoord::new(0.5, 0.5),
+            zoom2: 0.0,
+        }
+    }
+
+    pub fn top_left_coord(&self) -> MapCoord {
+        let scale = f64::powf(2.0, -self.zoom2) / 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)
+    }
+
+    pub fn map_to_screen_coord(&self, map_coord: MapCoord) -> ScreenCoord {
+        let scale = f64::powf(2.0, self.zoom2) * 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,
+        }
+    }
+
+    pub fn tile_screen_position(&self, tile: &Tile) -> ScreenCoord {
+        self.map_to_screen_coord(tile.map_coord())
+    }
+
+    pub fn visible_tiles(&self, snap_to_pixel: bool) -> Vec<VisibleTile> {
+        let uzoom = self.zoom2.floor().max(0.0) as u32;
+        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.zoom2 - 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.tile_x;
+        let start_tile_y = top_left_tile.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 = Tile::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
+    }
+
+    pub fn set_size(&mut self, width: f64, height: f64) {
+        self.width = width;
+        self.height = height;
+    }
+
+    pub fn set_zoom(&mut self, zoom: f64) {
+        self.zoom2 = zoom;
+    }
+
+    pub fn zoom(&mut self, zoom_delta: f64) {
+        self.zoom2 += zoom_delta;
+    }
+
+    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.zoom2) - f64::powf(2.0, -self.zoom2 - zoom_delta))
+            / f64::from(self.tile_size);
+        self.zoom2 += zoom_delta;
+
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+    }
+
+    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.zoom2) - f64::powf(2.0, -zoom)) / f64::from(self.tile_size);
+        self.zoom2 = zoom;
+
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+    }
+
+    pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
+        let scale = f64::powf(2.0, -self.zoom2) / f64::from(self.tile_size);
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+    }
+}

src/map_view_gl.rs

@@ -0,0 +1,186 @@
+use ::context;
+use ::std::ffi::CStr;
+use buffer::{Buffer, DrawMode};
+use context::Context;
+use coord::ScreenCoord;
+use image;
+use map_view::MapView;
+use program::Program;
+use texture::{Texture, TextureFormat};
+use tile_cache::TileCache;
+use tile_cache_gl::TileCacheGl;
+use tile_source::TileSource;
+
+
+#[derive(Debug)]
+pub struct MapViewGl<'a> {
+    cx: &'a Context,
+    program: Program<'a>,
+    buf: Buffer<'a>,
+    viewport_size: (u32, u32),
+    map_view: MapView,
+    tile_source: TileSource,
+    tile_cache: TileCache,
+    tile_cache_gl: TileCacheGl<'a>,
+}
+
+impl<'a> MapViewGl<'a> {
+    pub fn new<F>(cx: &Context, tile_source: TileSource, initial_size: (u32, u32), update_func: F) -> MapViewGl
+        where F: Fn() + Sync + Send + 'static,
+    {
+        println!("version: {}", cx.gl_version());
+        println!("max texture size: {}", cx.max_texture_size());
+        unsafe {
+            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);
+            check_gl_errors!(cx);
+            {
+                let img = image::open("no_tile.png").unwrap();
+                tex.sub_image(0, 0, &img);
+                check_gl_errors!(cx);
+            }
+
+            let buf = Buffer::new(cx, &[], 0);
+
+            check_gl_errors!(cx);
+
+            program.add_texture(&tex, CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
+            check_gl_errors!(cx);
+
+            program.add_attribute(CStr::from_bytes_with_nul(b"position\0").unwrap(), 2, 8, 0);
+            check_gl_errors!(cx);
+            program.add_attribute(CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(), 2, 8, 2);
+            check_gl_errors!(cx);
+            program.add_attribute(CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(), 4, 8, 4);
+            check_gl_errors!(cx);
+
+            program.before_render();
+
+            let tile_size = 256;
+            let mut map_view = MapView::new(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
+
+            // set initial zoom
+            {
+                let min_dimension = f64::from(initial_size.0.min(initial_size.1));
+                let zoom = (min_dimension / f64::from(tile_size)).log2().ceil();
+                map_view.set_zoom(zoom);
+            }
+
+            MapViewGl {
+                cx: cx,
+                program: program,
+                buf: buf,
+                viewport_size: initial_size,
+                map_view: map_view,
+                //TODO load templates from config
+                tile_source: tile_source,
+                tile_cache: TileCache::new(move |_tile| update_func()),
+                tile_cache_gl: TileCacheGl::new(tex, 256),
+            }
+        }
+    }
+
+    pub fn set_viewport_size(&mut self, width: u32, height: u32) {
+        self.viewport_size = (width, height);
+        self.map_view.set_size(f64::from(width), f64::from(height));
+        unsafe {
+            self.cx.gl.Viewport(
+                0,
+                0,
+                width as context::gl::types::GLsizei,
+                height as context::gl::types::GLsizei);
+        }
+    }
+
+    pub fn draw(&mut self) {
+        {
+            let visible_tiles = self.map_view.visible_tiles(true);
+            let textured_visible_tiles = self.tile_cache_gl.textured_visible_tiles(
+                &visible_tiles,
+                &self.tile_source,
+                &mut self.tile_cache,
+            );
+
+            let mut vertex_data: Vec<f32> = Vec::with_capacity(textured_visible_tiles.len() * (6 * 8));
+            let scale_x = 2.0 / f64::from(self.viewport_size.0);
+            let scale_y = -2.0 / f64::from(self.viewport_size.1);
+            for tvt in textured_visible_tiles {
+                let minmax = [
+                    tvt.tex_minmax.x1 as f32,
+                    tvt.tex_minmax.y1 as f32,
+                    tvt.tex_minmax.x2 as f32,
+                    tvt.tex_minmax.y2 as f32,
+                ];
+                let p1 = [
+                    (tvt.screen_rect.x * scale_x - 1.0) as f32,
+                    (tvt.screen_rect.y * scale_y + 1.0) as f32,
+                    tvt.tex_rect.x1 as f32,
+                    tvt.tex_rect.y1 as f32,
+                ];
+                let p2 = [
+                    (tvt.screen_rect.x * scale_x - 1.0) as f32,
+                    ((tvt.screen_rect.y + tvt.screen_rect.height) * scale_y + 1.0) as f32,
+                    tvt.tex_rect.x1 as f32,
+                    tvt.tex_rect.y2 as f32,
+                ];
+                let p3 = [
+                    ((tvt.screen_rect.x + tvt.screen_rect.width) * scale_x - 1.0) as f32,
+                    ((tvt.screen_rect.y + tvt.screen_rect.height) * scale_y + 1.0) as f32,
+                    tvt.tex_rect.x2 as f32,
+                    tvt.tex_rect.y2 as f32,
+                ];
+                let p4 = [
+                    ((tvt.screen_rect.x + tvt.screen_rect.width) * scale_x - 1.0) as f32,
+                    (tvt.screen_rect.y * scale_y + 1.0) as f32,
+                    tvt.tex_rect.x2 as f32,
+                    tvt.tex_rect.y1 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);
+            }
+
+            self.buf.set_data(&vertex_data, vertex_data.len() / 4);
+        }
+
+        self.cx.clear_color((0.9, 0.9, 0.9, 1.0));
+        self.buf.draw(DrawMode::Triangles);
+    }
+
+    pub fn zoom(&mut self, zoom_delta: f64) {
+        if self.map_view.zoom2 + zoom_delta < 0.0 {
+            self.map_view.set_zoom(0.0);
+        } else if self.map_view.zoom2 + zoom_delta > 22.0 {
+            self.map_view.set_zoom(22.0);
+        } else {
+            self.map_view.zoom(zoom_delta);
+        }
+    }
+
+    pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
+        if self.map_view.zoom2 + zoom_delta < 0.0 {
+            self.map_view.set_zoom_at(pos, 0.0);
+        } else if self.map_view.zoom2 + zoom_delta > 22.0 {
+            self.map_view.set_zoom_at(pos, 22.0);
+        } else {
+            self.map_view.zoom_at(pos, zoom_delta);
+        }
+        self.map_view.center.normalize_xy();
+    }
+
+    pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
+        self.map_view.move_pixel(delta_x, delta_y);
+        self.map_view.center.normalize_xy();
+    }
+}

src/program.rs

@@ -0,0 +1,203 @@
+use ::context;
+use context::Context;
+use std::ffi::CStr;
+use std::fs::File;
+use std::io::BufReader;
+use std::io::Read;
+use std::mem;
+use std::path::Path;
+use texture::{Texture, TextureId};
+
+#[derive(Clone, Debug)]
+pub struct Program<'a> {
+    cx: &'a ::context::Context,
+    vert_obj: u32,
+    frag_obj: u32,
+    program_obj: u32,
+    tex_ids: Vec<TextureId>,
+    tex_locations: Vec<i32>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ProgramId {
+    id: u32,
+}
+
+impl<'a> Program<'a> {
+    pub unsafe fn from_paths<P: AsRef<Path>>(cx: &'a Context, vert_path: P, frag_path: P) -> Program<'a> {
+        let vert_src = {
+            let file = File::open(&vert_path).unwrap();
+            let mut reader = BufReader::new(file);
+            let mut buf: Vec<u8> = vec![];
+            reader.read_to_end(&mut buf).unwrap();
+            buf
+        };
+
+        let frag_src = {
+            let file = File::open(&frag_path).unwrap();
+            let mut reader = BufReader::new(file);
+            let mut buf: Vec<u8> = vec![];
+            reader.read_to_end(&mut buf).unwrap();
+            buf
+        };
+
+        Self::new(cx, &vert_src, &frag_src)
+    }
+
+    pub unsafe fn new(cx: &'a Context, vert_src: &[u8], frag_src: &[u8]) -> Program<'a> {
+        let vert_obj = {
+            let vert_obj = cx.gl.CreateShader(context::gl::VERTEX_SHADER);
+            let vert_len = vert_src.len() as i32;
+            cx.gl.ShaderSource(
+                vert_obj,
+                1,
+                [vert_src.as_ptr() as *const _].as_ptr(),
+                &vert_len as *const _);
+            cx.gl.CompileShader(vert_obj);
+            check_compile_errors(cx, vert_obj);
+            check_gl_errors!(cx);
+            vert_obj
+        };
+
+        let frag_obj = {
+            let frag_obj = cx.gl.CreateShader(context::gl::FRAGMENT_SHADER);
+            let frag_len = frag_src.len() as i32;
+            cx.gl.ShaderSource(
+                frag_obj,
+                1,
+                [frag_src.as_ptr() as *const _].as_ptr(),
+                &frag_len as *const _);
+            cx.gl.CompileShader(frag_obj);
+            check_compile_errors(cx, frag_obj);
+            check_gl_errors!(cx);
+            frag_obj
+        };
+
+        let program_obj = {
+            let prog = cx.gl.CreateProgram();
+            cx.gl.AttachShader(prog, vert_obj);
+            cx.gl.AttachShader(prog, frag_obj);
+            cx.gl.LinkProgram(prog);
+            check_link_errors(cx, prog);
+
+            cx.gl.UseProgram(prog);
+            check_gl_errors!(cx);
+            prog
+        };
+
+        Program {
+            cx: cx,
+            vert_obj: vert_obj,
+            frag_obj: frag_obj,
+            program_obj: program_obj,
+            tex_ids: vec![],
+            tex_locations: vec![],
+        }
+    }
+
+    pub unsafe fn add_texture(&mut self, texture: &Texture, uniform_name: &CStr) {
+        //TODO store reference to texture
+        let tex_loc = self.cx.gl.GetUniformLocation(self.program_obj, uniform_name.as_ptr() as *const _);
+        check_gl_errors!(self.cx);
+
+        self.tex_ids.push(texture.id());
+        self.tex_locations.push(tex_loc);
+
+    }
+
+    pub unsafe fn add_attribute(&mut self, name: &CStr, number_components: u32, stride: usize, offset: usize) {
+        let attrib_id = self.cx.gl.GetAttribLocation(self.program_obj, name.as_ptr() as *const _);
+        check_gl_errors!(self.cx);
+        self.cx.gl.VertexAttribPointer(
+            attrib_id as u32,
+            number_components as i32, // size
+            context::gl::FLOAT, // type
+            0, // normalized
+            (stride * mem::size_of::<f32>()) as context::gl::types::GLsizei,
+            (offset * mem::size_of::<f32>()) as *const () as *const _);
+        check_gl_errors!(self.cx);
+        self.cx.gl.EnableVertexAttribArray(attrib_id as u32);
+        check_gl_errors!(self.cx);
+    }
+
+    pub unsafe fn before_render(&self) {
+        check_gl_errors!(self.cx);
+        //self.cx.gl.UseProgram(self.program_obj);
+        //TODO check max texture number
+        for (i, (tex_id, &tex_loc)) in self.tex_ids.iter().zip(&self.tex_locations).enumerate() {
+            self.cx.gl.ActiveTexture(context::gl::TEXTURE0 + i as u32);
+            self.cx.gl.BindTexture(context::gl::TEXTURE_2D, tex_id.id);
+            self.cx.gl.Uniform1i(tex_loc, i as i32);
+        }
+    }
+
+    pub fn id(&self) -> ProgramId {
+        ProgramId {
+            id: self.program_obj,
+        }
+    }
+}
+
+unsafe fn check_link_errors(cx: &Context, program_obj: u32)
+{
+    let mut link_success: i32 = mem::uninitialized();
+
+    cx.gl.GetProgramiv(program_obj, context::gl::LINK_STATUS, &mut link_success);
+
+    if link_success == 0 {
+
+        match cx.gl.GetError() {
+            context::gl::NO_ERROR => (),
+            context::gl::INVALID_VALUE => {
+                println!("invalid value");
+                return;
+            },
+            context::gl::INVALID_OPERATION => {
+                println!("invalid operation");
+                return;
+            },
+            _ => {
+                println!("unknown error");
+                return;
+            }
+        };
+
+        let mut error_log_size: i32 = mem::uninitialized();
+
+        cx.gl.GetProgramiv(program_obj, context::gl::INFO_LOG_LENGTH, &mut error_log_size);
+
+        let mut error_log: Vec<u8> = Vec::with_capacity(error_log_size as usize);
+
+        cx.gl.GetProgramInfoLog(program_obj, error_log_size, &mut error_log_size,
+                             error_log.as_mut_ptr() as *mut context::gl::types::GLchar);
+
+        error_log.set_len(error_log_size as usize);
+
+        let msg = String::from_utf8(error_log).unwrap();
+        println!("{}", msg);
+    }
+}
+
+unsafe fn check_compile_errors(cx: &Context, shader_obj: u32) {
+    // checking compilation success by reading a flag on the shader
+    let compilation_success = {
+        let mut compilation_success: i32 = mem::uninitialized();
+        cx.gl.GetShaderiv(shader_obj, context::gl::COMPILE_STATUS, &mut compilation_success);
+        compilation_success
+    };
+
+    if compilation_success != 1 {
+        // compilation error
+        let mut error_log_size: i32 = mem::uninitialized();
+        cx.gl.GetShaderiv(shader_obj, context::gl::INFO_LOG_LENGTH, &mut error_log_size);
+        let mut error_log: Vec<u8> = Vec::with_capacity(error_log_size as usize);
+
+        cx.gl.GetShaderInfoLog(shader_obj, error_log_size, &mut error_log_size,
+                                 error_log.as_mut_ptr() as *mut _);
+        error_log.set_len(error_log_size as usize);
+
+        if let Ok(msg) = String::from_utf8(error_log) {
+            println!("{}", msg);
+        }
+    }
+}

src/texture.rs

@@ -0,0 +1,121 @@
+use ::context;
+use ::image;
+use context::Context;
+use image::GenericImage;
+use std::os::raw::c_void;
+
+#[derive(Clone, Debug)]
+pub struct Texture<'a> {
+    cx: &'a Context,
+    texture_obj: u32,
+    width: u32,
+    height: u32,
+}
+
+#[derive(Clone, Debug)]
+pub struct TextureId {
+    pub(crate) id: u32,
+}
+
+impl<'a> Texture<'a> {
+    pub fn new(cx: &'a Context, img: &image::DynamicImage) -> Result<Texture<'a>, ()> {
+        let format = match *img {
+            image::ImageRgb8(_) => TextureFormat::Rgb8,
+            image::ImageRgba8(_) => TextureFormat::Rgba8,
+            _ => return Err(()),
+        };
+
+        Ok(Self::from_bytes(cx, img.width(), img.height(), format, &img.raw_pixels()))
+    }
+
+    pub fn empty(cx: &'a Context, width: u32, height: u32, format: TextureFormat) -> Texture<'a> {
+        Self::from_ptr(cx, width, height, format, ::std::ptr::null() as *const _)
+    }
+
+    pub fn from_bytes(cx: &'a Context, width: u32, height: u32, format: TextureFormat, data: &[u8]) -> Texture<'a> {
+        Self::from_ptr(cx, width, height, format, data.as_ptr() as *const _)
+    }
+
+    fn from_ptr(cx: &'a Context, width: u32, height: u32, format: TextureFormat, data_ptr: *const c_void) -> Texture<'a> {
+        let mut tex_obj = 0_u32;
+        unsafe {
+            cx.gl.GenTextures(1, &mut tex_obj);
+            cx.gl.BindTexture(context::gl::TEXTURE_2D, tex_obj);
+
+            cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_MIN_FILTER, context::gl::LINEAR as i32);
+            cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_MAG_FILTER, context::gl::LINEAR as i32);
+            cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_WRAP_S, context::gl::CLAMP_TO_EDGE as i32);
+            cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_WRAP_T, context::gl::CLAMP_TO_EDGE as i32);
+
+            cx.gl.TexImage2D(
+                context::gl::TEXTURE_2D,
+                0, // level
+                format.to_gl_enum() as i32,
+                width as i32,
+                height as i32,
+                0, // border (must be zero)
+                format.to_gl_enum(),
+                context::gl::UNSIGNED_BYTE,
+                data_ptr);
+        }
+
+        Texture {
+            cx: cx,
+            texture_obj: tex_obj,
+            width: width,
+            height: height,
+        }
+    }
+
+    pub fn sub_image(&mut self, x: i32, y: i32, img: &image::DynamicImage) {
+        let format = match *img {
+            image::ImageRgb8(_) => TextureFormat::Rgb8,
+            image::ImageRgba8(_) => TextureFormat::Rgba8,
+            _ => return,
+        };
+
+        unsafe {
+            self.cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
+            self.cx.gl.TexSubImage2D(
+                context::gl::TEXTURE_2D,
+                0, // level
+                x, // x offset
+                y, // y offset
+                img.width() as i32,
+                img.height() as i32,
+                format.to_gl_enum(),
+                context::gl::UNSIGNED_BYTE,
+                img.raw_pixels().as_ptr() as *const _,
+            );
+        }
+    }
+
+    pub fn id(&self) -> TextureId {
+        TextureId {
+            id: self.texture_obj,
+        }
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum TextureFormat {
+    Rgb8,
+    Rgba8,
+}
+
+impl TextureFormat {
+    pub fn to_gl_enum(self) -> u32 {
+        match self {
+            TextureFormat::Rgb8 => context::gl::RGB,
+            TextureFormat::Rgba8 => context::gl::RGBA,
+        }
+    }
+}

src/tile.rs

@@ -0,0 +1,70 @@
+use coord::MapCoord;
+
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Tile {
+    pub zoom: u32,
+    pub tile_x: i32,
+    pub tile_y: i32,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SubTileCoord {
+    pub size: u32,
+    pub x: u32,
+    pub y: u32,
+}
+
+impl Tile {
+    pub fn new(zoom: u32, tile_x: i32, tile_y: i32) -> Tile {
+        Tile {
+            zoom: zoom,
+            tile_x: Self::normalize_coord(tile_x, zoom),
+            tile_y: tile_y,
+        }
+    }
+
+    pub fn is_on_planet(&self) -> bool {
+        let num_tiles = Self::get_zoom_level_tiles(self.zoom);
+        self.tile_y >= 0 && self.tile_y < num_tiles &&
+        self.tile_x >= 0 && self.tile_x < num_tiles
+    }
+
+    pub fn map_coord(&self) -> MapCoord {
+        let inv_zoom_factor = f64::powi(2.0, -(self.zoom as i32));
+        MapCoord::new(f64::from(self.tile_x) * inv_zoom_factor, f64::from(self.tile_y) * inv_zoom_factor)
+    }
+
+    pub fn parent(&self, distance: u32) -> Option<(Tile, SubTileCoord)> {
+        if distance > self.zoom {
+            None
+        } else {
+            let scale = u32::pow(2, distance);
+
+            Some((
+                Tile {
+                    zoom: self.zoom - distance,
+                    tile_x: self.tile_x / scale as i32,
+                    tile_y: self.tile_y / scale as i32,
+                },
+                SubTileCoord {
+                    size: scale,
+                    x: (Self::normalize_coord(self.tile_x, self.zoom) as u32) % scale,
+                    y: (Self::normalize_coord(self.tile_y, self.zoom) as u32) % scale,
+                },
+            ))
+        }
+    }
+
+    #[inline]
+    fn normalize_coord(coord: i32, zoom: u32) -> i32 {
+        let max = Self::get_zoom_level_tiles(zoom);
+        ((coord % max) + max) % max
+    }
+
+    #[inline]
+    pub fn get_zoom_level_tiles(zoom: u32) -> i32 {
+        //TODO throw error when zoom too big
+        i32::pow(2, zoom)
+    }
+}

src/tile_cache.rs

@@ -0,0 +1,98 @@
+use image;
+use linked_hash_map::{Entry, LinkedHashMap};
+use tile::Tile;
+use tile_loader::TileLoader;
+use tile_source::TileSource;
+
+
+pub struct TileCache {
+    loader: TileLoader,
+    map: LinkedHashMap<Tile, image::DynamicImage>,
+    max_tiles: usize,
+}
+
+impl TileCache {
+    pub fn new<F>(new_tile_func: F) -> Self
+        where F: Fn(Tile) + Sync + Send + 'static,
+    {
+        TileCache {
+            loader: TileLoader::new(move |tile| {
+                new_tile_func(tile);
+            }),
+            map: LinkedHashMap::new(),
+            max_tiles: 512, //TODO set a reasonable value
+        }
+    }
+
+    pub fn get_sync(
+        &mut self,
+        tile: Tile,
+        source: &TileSource,
+        write_to_file: bool,
+        ) -> Option<&image::DynamicImage>
+    {
+        //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
+        self.map.get_refresh(&tile);
+
+        // remove old cache entries
+        while self.map.len() + 1 > self.max_tiles {
+            self.map.pop_front();
+        }
+
+        match self.map.entry(tile) {
+            Entry::Occupied(entry) => {
+                Some(entry.into_mut())
+            },
+            Entry::Vacant(entry) => {
+                self.loader.get_sync(tile, source, write_to_file).map(|img| entry.insert(img) as &_)
+            },
+        }
+    }
+
+    pub fn get_async(
+        &mut self,
+        tile: Tile,
+        source: &TileSource,
+        write_to_file: bool,
+        ) -> Option<&image::DynamicImage>
+    {
+        while let Some((t, img)) = self.loader.async_result() {
+            // remove old cache entries
+            while self.map.len() + 1 > self.max_tiles {
+                self.map.pop_front();
+            }
+
+            self.map.insert(t, img);
+            println!("CACHE SIZE: {} tiles", self.map.len());
+        }
+
+        //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
+        self.map.get_refresh(&tile);
+
+        match self.map.entry(tile) {
+            Entry::Occupied(entry) => Some(entry.into_mut()),
+            Entry::Vacant(_) => {
+                self.loader.async_request(tile, source, write_to_file);
+                None
+            }
+        }
+    }
+
+    // Return a tile from the cache but do not use TileLoader.
+    pub fn lookup(&mut self, tile: Tile, source: &TileSource) -> Option<&image::DynamicImage> {
+        //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
+        self.map.get_refresh(&tile);
+
+        self.map.get(&tile)
+    }
+}
+
+impl ::std::fmt::Debug for TileCache {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(
+            f,
+            "TileCache {{ tiles: {:?} }}",
+            self.map.keys().collect::<Vec<_>>()
+        )
+    }
+}

src/tile_cache_async.rs

@@ -0,0 +1,145 @@
+use image::DynamicImage;
+use image;
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+use std::ops::Deref;
+use std::sync::{Arc, Mutex, MutexGuard};
+use tile::Tile;
+use tile_loader::TileLoader;
+use tile_source::TileSource;
+
+
+pub struct TileCache {
+    loader: TileLoader,
+    map: Arc<Mutex<HashMap<Tile, image::DynamicImage>>>,
+}
+
+impl TileCache {
+    pub fn new<F>(new_tile_func: F) -> Self
+        where F: Fn(Tile) + Sync + Send + 'static,
+    {
+        let map = Arc::new(Mutex::new(HashMap::new()));
+        TileCache {
+            loader: TileLoader::new(TileSource::new(), move |tile| {
+                println!("TILECACHE NEW tile {:?}", tile);
+                new_tile_func(tile);
+            }),
+            map: map,
+        }
+    }
+
+    pub fn get_sync(&mut self, tile: Tile, source: &TileSource) -> Option<ImgRef> {
+        if let Ok(mut lock) = self.map.lock() {
+            let contains = lock.contains_key(&tile);
+
+            if contains {
+                Some(ImgRef {
+                    guard: lock,
+                    key: tile,
+                })
+            } else {
+                if let Some(img) = self.loader.get_sync(tile, source) {
+                    lock.insert(tile, img);
+
+                    Some(ImgRef {
+                        guard: lock,
+                        key: tile,
+                    })
+                } else {
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    //TODO Return ImgRef, do not clone
+    pub fn get_async(&mut self, tile: Tile, source: &TileSource) -> Option<&DynamicImage> {
+        if let Ok(mut lock) = self.map.lock() {
+            match lock.entry(tile) {
+                Entry::Occupied(entry) => Some(entry.into_mut().clone()),
+                Entry::Vacant(_) => {
+                    self.loader.async_request(tile);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    /*
+    //TODO Return ImgRef, do not clone
+    pub fn get_sync(&mut self, tile: Tile, source: &TileSource) -> Option<ImgRef> {
+        if let Ok(mut lock) = self.map.lock() {
+            let contains = lock.contains_key(&tile);
+
+            if contains {
+                Some(ImgRef {
+                    guard: lock,
+                    key: tile,
+                })
+            } else {
+                if let Some(img) = self.loader.get_sync(tile, source) {
+                    lock.insert(tile, img);
+
+                    Some(ImgRef {
+                        guard: lock,
+                        key: tile,
+                    })
+                } else {
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    //TODO Return ImgRef, do not clone
+    pub fn get_async(&mut self, tile: Tile, source: &TileSource) -> Option<DynamicImage> {
+        if let Ok(mut lock) = self.map.lock() {
+            match lock.entry(tile) {
+                Entry::Occupied(entry) => Some(entry.into_mut().clone()),
+                Entry::Vacant(_) => {
+                    self.loader.async_request(tile);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+    */
+}
+
+impl ::std::fmt::Debug for TileCache {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        if let Ok(lock) = self.map.try_lock() {
+            write!(
+                f,
+                "TileCache {{ tiles: {:?} }}",
+                lock.keys().collect::<Vec<_>>()
+            )
+        } else {
+            write!(
+                f,
+                "TileCache {{ tiles: <not accessible> }}",
+            )
+        }
+    }
+}
+
+pub struct ImgRef<'a> {
+    guard: MutexGuard<'a, HashMap<Tile, DynamicImage>>,
+    key: Tile,
+}
+
+impl<'a> Deref for ImgRef<'a> {
+    type Target = DynamicImage;
+    fn deref(&self) -> &Self::Target {
+        println!("DEREF {:?}", self.key);
+        self.guard.get(&self.key).unwrap()
+    }
+}

src/tile_cache_gl.rs

@@ -0,0 +1,194 @@
+use coord::ScreenRect;
+use linked_hash_map::LinkedHashMap;
+use map_view::VisibleTile;
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+use texture::Texture;
+use tile::{Tile, SubTileCoord};
+use tile_cache::TileCache;
+use tile_source::TileSource;
+
+#[derive(Copy, Clone, Debug)]
+pub struct TextureRect {
+    pub x1: f64,
+    pub y1: f64,
+    pub x2: f64,
+    pub y2: f64,
+}
+
+impl TextureRect {
+    pub fn inset(self, margin_x: f64, margin_y: f64) -> TextureRect {
+        TextureRect {
+            x1: self.x1 + margin_x,
+            y1: self.y1 + margin_y,
+            x2: self.x2 - margin_x,
+            y2: self.y2 - margin_y,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TexturedVisibleTile {
+    pub screen_rect: ScreenRect,
+    pub tex_rect: TextureRect,
+    pub tex_minmax: TextureRect,
+}
+
+#[derive(Clone, Debug)]
+pub struct TileCacheGl<'a> {
+    texture: Texture<'a>,
+    tile_size: u32,
+    slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
+    tile_to_slot: HashMap<Tile, CacheSlot>,
+}
+
+impl<'a> TileCacheGl<'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;
+        let num_slots = (slots_x * slots_y) as usize;
+
+        let mut slots_lru = LinkedHashMap::with_capacity(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);
+            }
+        }
+
+        slots_lru.remove(&Self::default_slot());
+
+        TileCacheGl {
+            texture: tex,
+            tile_size: tile_size,
+            slots_lru: slots_lru,
+            tile_to_slot: HashMap::with_capacity(num_slots),
+        }
+    }
+
+    pub fn default_slot() -> CacheSlot {
+        CacheSlot { x: 0, y: 0 }
+    }
+
+    pub fn store(&mut self, tile: Tile, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
+        let mut remove_tile = None;
+
+        let slot = match self.tile_to_slot.entry(tile) {
+            Entry::Vacant(entry) => {
+                let img_option = if load {
+                    cache.get_async(tile, source, true)
+                } else {
+                    cache.lookup(tile, source)
+                };
+
+                if let Some(img) = img_option {
+                    let (slot, old_tile) = self.slots_lru.pop_front().unwrap();
+                    self.slots_lru.insert(slot, Some(tile));
+
+                    remove_tile = old_tile;
+
+                    self.texture.sub_image(
+                        (slot.x * self.tile_size) as i32,
+                        (slot.y * self.tile_size) as i32,
+                        img,
+                    );
+                    Some(*entry.insert(slot))
+                } else {
+                    None
+                }
+            },
+            Entry::Occupied(entry) => {
+                let slot = *entry.into_mut();
+
+                self.slots_lru.get_refresh(&slot);
+
+                Some(slot)
+            },
+        };
+
+        if let Some(t) = remove_tile {
+            self.tile_to_slot.remove(&t);
+        }
+
+        slot
+    }
+
+    pub fn textured_visible_tiles(
+        &mut self,
+        visible_tiles: &[VisibleTile],
+        source: &TileSource,
+        cache: &mut TileCache,
+        ) -> Vec<TexturedVisibleTile>
+    {
+        let mut tvt = Vec::with_capacity(visible_tiles.len());
+
+        let inset_x = 0.5 / f64::from(self.texture.width());
+        let inset_y = 0.5 / f64::from(self.texture.height());
+
+        for vt in visible_tiles {
+            if let Some(slot) = self.store(vt.tile, source, cache, true) {
+                let tex_rect = self.slot_to_texture_rect(slot);
+                tvt.push(
+                    TexturedVisibleTile {
+                        screen_rect: vt.rect,
+                        tex_rect: tex_rect,
+                        tex_minmax: tex_rect.inset(inset_x, inset_y),
+                    }
+                );
+            } else {
+                // look for cached tiles in lower zoom layers
+                let mut tex_sub_rect = self.slot_to_texture_rect(Self::default_slot());
+                let mut tex_rect = tex_sub_rect;
+                for dist in 1..31 {
+                    if let Some((parent_tile, sub_coord)) = vt.tile.parent(dist) {
+                        if let Some(slot) = self.store(parent_tile, source, cache, false) {
+                            tex_sub_rect = self.subslot_to_texture_rect(slot, sub_coord);
+                            tex_rect = self.slot_to_texture_rect(slot);
+                            break;
+                        }
+                    }
+                }
+                tvt.push(
+                    TexturedVisibleTile {
+                        screen_rect: vt.rect,
+                        tex_rect: tex_sub_rect,
+                        tex_minmax: tex_rect.inset(inset_x, inset_y),
+                    }
+                );
+            };
+
+        }
+
+        tvt
+    }
+
+    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());
+
+        TextureRect {
+            x1: f64::from(slot.x) * scale_x,
+            y1: f64::from(slot.y) * scale_y,
+            x2: f64::from(slot.x + 1) * scale_x,
+            y2: f64::from(slot.y + 1) * scale_y,
+        }
+    }
+
+    fn subslot_to_texture_rect(&self, slot: CacheSlot, sub_coord: SubTileCoord) -> TextureRect {
+        let scale_x = f64::from(self.tile_size) / (f64::from(self.texture.width()) * f64::from(sub_coord.size));
+        let scale_y = f64::from(self.tile_size) / (f64::from(self.texture.height()) * f64::from(sub_coord.size));
+
+        TextureRect {
+            x1: f64::from(slot.x * sub_coord.size + sub_coord.x) * scale_x,
+            y1: f64::from(slot.y * sub_coord.size + sub_coord.y) * scale_y,
+            x2: f64::from(slot.x * sub_coord.size + sub_coord.x + 1) * scale_x,
+            y2: f64::from(slot.y * sub_coord.size + sub_coord.y + 1) * scale_y,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct CacheSlot {
+    pub x: u32,
+    pub y: u32,
+}

src/tile_loader.rs

@@ -0,0 +1,165 @@
+use image::DynamicImage;
+use image;
+use reqwest::Client;
+use std::collections::hash_set::HashSet;
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::mpsc;
+use std::thread;
+use tile::Tile;
+use tile_source::TileSource;
+
+
+//TODO remember failed loading attempts
+
+#[derive(Debug)]
+pub struct TileLoader {
+    client: Option<Client>,
+    join_handle: thread::JoinHandle<()>,
+    request_tx: mpsc::Sender<(Tile, String, PathBuf, bool)>,
+    result_rx: mpsc::Receiver<(Tile, Option<DynamicImage>)>,
+    //TODO store source together with tile in pending
+    pending: HashSet<Tile>,
+}
+
+impl TileLoader {
+    pub fn new<F>(notice_func: F) -> Self
+        where F: Fn(Tile) + Sync + Send + 'static,
+    {
+        let (request_tx, request_rx) = mpsc::channel();
+        let (result_tx, result_rx) = mpsc::channel();
+
+        TileLoader {
+            client: None,
+            join_handle: thread::spawn(move || Self::work(request_rx, result_tx, notice_func)),
+            request_tx: request_tx,
+            result_rx: result_rx,
+            pending: HashSet::new(),
+        }
+    }
+
+    fn work<F>(
+        request_rx: mpsc::Receiver<(Tile, String, PathBuf, bool)>,
+        result_tx: mpsc::Sender<(Tile, Option<DynamicImage>)>,
+        notice_func: F,
+    )
+        where F: Fn(Tile) + Sync + Send + 'static,
+    {
+        let mut client_opt = None;
+        while let Ok((tile, url, path, write_to_file)) = request_rx.recv() {
+            println!("work {:?}", tile);
+            match image::open(&path) {
+                Ok(img) => {
+                    result_tx.send((tile, Some(img))).unwrap();
+                    notice_func(tile);
+                    continue;
+                },
+                Err(_) => {
+                    //TODO do not try to create a client every time when it failed before
+                    if client_opt.is_none() {
+                        client_opt = Client::builder().build().ok();
+                    }
+
+                    if let Some(ref client) = client_opt {
+                        println!("use client {:?}", tile);
+                        if let Ok(mut response) = client.get(&url).send() {
+                            let mut buf: Vec<u8> = vec![];
+                            response.copy_to(&mut buf).unwrap();
+                            if let Ok(img) = image::load_from_memory(&buf) {
+                                result_tx.send((tile, Some(img))).unwrap();
+                                notice_func(tile);
+
+                                if write_to_file {
+                                    //TODO do something on write errors
+                                    let _ = Self::write_to_file(&path, &buf);
+                                }
+
+                                continue;
+                            }
+                        }
+                    }
+                },
+            }
+            result_tx.send((tile, None)).unwrap();
+        }
+    }
+
+    pub fn async_request(&mut self, tile: Tile, source: &TileSource, write_to_file: bool) {
+        if tile.zoom > source.max_tile_zoom() {
+            return;
+        }
+
+        if !self.pending.contains(&tile) {
+            self.pending.insert(tile);
+            self.request_tx.send((
+                tile,
+                source.remote_tile_url(tile),
+                source.local_tile_path(tile),
+                write_to_file
+            )).unwrap();
+        }
+    }
+
+    pub fn async_result(&mut self) -> Option<(Tile, DynamicImage)> {
+        match self.result_rx.try_recv() {
+            Err(_) => None,
+            Ok((tile, None)) => {
+                self.pending.remove(&tile);
+                None
+            },
+            Ok((tile, Some(img))) => {
+                self.pending.remove(&tile);
+                Some((tile, img))
+            },
+        }
+    }
+
+    pub fn get_sync(&mut self, tile: Tile, source: &TileSource, write_to_file: bool) -> Option<DynamicImage> {
+        match image::open(source.local_tile_path(tile)) {
+            Ok(img) => {
+                Some(img)
+            },
+            Err(_) => {
+                //TODO do not try to create a client every time when it failed before
+                if self.client.is_none() {
+                    self.client = Client::builder().build().ok();
+                }
+
+                if let Some(ref client) = self.client {
+                    println!("use client {:?}", tile);
+                    if let Ok(mut response) = client.get(&source.remote_tile_url(tile)).send() {
+                        let mut buf: Vec<u8> = vec![];
+                        response.copy_to(&mut buf).unwrap();
+                        if let Ok(img) = image::load_from_memory(&buf) {
+                            if write_to_file {
+                                let path = source.local_tile_path(tile);
+                                let _ = Self::write_to_file(path, &buf);
+                            }
+                            Some(img)
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            },
+        }
+    }
+
+    fn write_to_file<P: AsRef<Path>>(path: P, img_data: &[u8]) -> ::std::io::Result<()> {
+
+        if let Some(dir) = path.as_ref().parent() {
+            ::std::fs::create_dir_all(dir)?;
+        }
+
+        //TODO remove
+        println!("write file {:?}", path.as_ref());
+
+        let mut file = File::create(path)?;
+        file.write_all(img_data)
+    }
+}

src/tile_source.rs

@@ -0,0 +1,71 @@
+use tile::Tile;
+use std::path::{Path, PathBuf};
+
+
+#[derive(Clone, Debug)]
+pub struct TileSource {
+    id: u32,
+    url_template: String,
+    directory: PathBuf,
+    max_zoom: u32,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct TileSourceId {
+    id: u32,
+}
+
+impl TileSource {
+    pub fn new<S: Into<String>, P: Into<PathBuf>>(
+        id: u32,
+        url_template: S,
+        directory: P,
+        max_zoom: u32,
+    ) -> Self {
+        TileSource {
+            id: id,
+            url_template: url_template.into(),
+            directory: directory.into(),
+            max_zoom: max_zoom,
+        }
+    }
+
+    pub fn id(&self) -> TileSourceId {
+        TileSourceId {
+            id: self.id,
+        }
+    }
+
+    pub fn local_tile_path(&self, tile: Tile) -> PathBuf {
+
+        let mut path = PathBuf::from(&self.directory);
+        path.push(tile.zoom.to_string());
+        path.push(tile.tile_x.to_string());
+        path.push(tile.tile_y.to_string() + ".png");
+
+        path
+    }
+
+    pub fn remote_tile_url(&self, tile: Tile) -> String {
+        Self::fill_template(&self.url_template, tile)
+    }
+
+    pub fn max_tile_zoom(&self) -> u32 {
+        self.max_zoom
+    }
+
+    fn fill_template(template: &str, tile: Tile) -> String {
+        let x_str = tile.tile_x.to_string();
+        let y_str = tile.tile_y.to_string();
+        let z_str = tile.zoom.to_string();
+
+        //let len = (template.len() + x_str.len() + y_str.len() + z_str.len()).saturating_sub(9);
+
+        //TODO use the regex crate for templates or some other more elegant method
+        let string = template.replacen("{x}", &x_str, 1);
+        let string = string.replacen("{y}", &y_str, 1);
+        let string = string.replacen("{z}", &z_str, 1);
+
+        return string;
+    }
+}