Add overly dramatic atmosphere layer

Toggle with Ctrl+h

shader/atmos.frag

+#version 100
+precision mediump float;
+
+varying vec2 v_pos;
+
+void main() {
+    //float len = abs(1.0 - length(v_pos));
+    //float val = (1.0 - sqrt(sqrt(len*4.0))) * (1.0 - len*5.0);
+    float len = length(v_pos);
+    //float val = max(0.0, sqrt(1.1*1.1 - len*len) * 1.5) * step(0.99, len);
+    float val = exp(abs(1.0 - len)*(-16.0 - step(1.0, len)*16.0));
+    gl_FragColor = vec4(sin(val*1.0) * 0.8 + 0.2, sin(val*1.5) * 0.8 + 0.2 , 1.0, val * 1.0);
+}

shader/atmos.vert

+#version 100
+precision mediump float;
+
+attribute vec2 position;
+
+uniform vec2 scale;
+
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = vec4(position * scale, 0.0, 1.0);
+    v_pos = position;
+}

src/atmos_layer.rs

+use ::std::ffi::CStr;
+use buffer::{Buffer, DrawMode};
+use context::Context;
+use map_view::MapView;
+use orthografic_view::OrthograficView;
+use program::{Program, UniformId};
+use std::f32::consts::PI;
+use vertex_attrib::VertexAttribParams;
+
+
+#[derive(Debug)]
+pub struct AtmosLayer {
+    buffer: Buffer,
+    program: Program,
+    scale_uniform: UniformId,
+}
+
+impl AtmosLayer {
+    pub fn new(cx: &mut Context) -> AtmosLayer {
+        let vertex_data = {
+            let mut vertex_data: Vec<f32> = Vec::with_capacity(17 * 4);
+
+            let radius_a = 0.75;
+            let radius_b = 1.25;
+            for x in 0..17 {
+                let angle = x as f32 * (PI * 2.0 / 16.0);
+                vertex_data.extend(&[
+                    angle.cos() * radius_a,
+                    angle.sin() * radius_a,
+                    angle.cos() * radius_b,
+                    angle.sin() * radius_b,
+                ]);
+            }
+
+            vertex_data
+        };
+
+        let buffer = Buffer::new(cx, &vertex_data, vertex_data.len() / 2);
+
+        let mut program = Program::new(
+            cx,
+            include_bytes!("../shader/atmos.vert"),
+            include_bytes!("../shader/atmos.frag"),
+        ).unwrap();
+
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"position\0").unwrap(),
+            &VertexAttribParams::new(2, 2, 0)
+        );
+
+        let scale_uniform = program.get_uniform_id(cx, CStr::from_bytes_with_nul(b"scale\0").unwrap()).unwrap();
+
+        check_gl_errors!(cx);
+
+        AtmosLayer {
+            buffer,
+            program,
+            scale_uniform,
+        }
+    }
+
+    // Has to be called once before one or multiple calls to `draw`.
+    pub fn prepare_draw(&mut self, cx: &mut Context) {
+        self.program.enable_vertex_attribs(cx);
+        self.program.set_vertex_attribs(cx, &self.buffer);
+    }
+
+    pub fn draw(
+        &mut self,
+        cx: &mut Context,
+        map_view: &MapView,
+    ) {
+        let (scale_x, scale_y) = {
+            let radius = OrthograficView::radius_physical_pixels(map_view);
+            ((radius / map_view.width) as f32, (radius / map_view.height) as f32)
+        };
+
+        self.program.set_uniform_2f(cx, self.scale_uniform, scale_x, scale_y);
+
+        self.buffer.draw(cx, &self.program, DrawMode::TriangleStrip);
+    }
+}

src/main.rs

 extern crate scoped_threadpool;
 extern crate toml;
 
+#[macro_use]
+pub mod context;
+
 pub mod args;
+pub mod atmos_layer;
 pub mod buffer;
 pub mod config;
-#[macro_use]
-pub mod context;
 pub mod coord;
 pub mod map_view;
 pub mod map_view_gl;
                             Action::Nothing
                         }
                     },
+                    VirtualKeyCode::H => {
+                        if modifiers.ctrl {
+                            map.toggle_atmosphere();
+                            Action::Redraw
+                        } else {
+                            Action::Nothing
+                        }
+                    },
                     _ => Action::Nothing,
                 }
             },

src/map_view_gl.rs

+use atmos_layer::AtmosLayer;
 use context::Context;
 use coord::{MapCoord, ScreenCoord};
 use map_view::MapView;
     mercator_tile_layer: MercatorTileLayer,
     marker_layer: MarkerLayer,
     ortho_tile_layer: OrthoTileLayer,
+    atmos_layer: AtmosLayer,
     projection: Projection,
+    show_atmos: bool,
     last_draw_type: DrawType,
 }
 
     Tiles,
     Markers,
     OrthoTiles,
+    Atmos,
 }
 
 impl MapViewGl {
 
         let mercator_tile_layer = MercatorTileLayer::new(cx, &tile_atlas);
         let ortho_tile_layer = OrthoTileLayer::new(cx, &tile_atlas);
+        let atmos_layer = AtmosLayer::new(cx);
 
         MapViewGl {
             map_view,
             mercator_tile_layer,
             marker_layer: MarkerLayer::new(cx),
             ortho_tile_layer,
+            atmos_layer,
             projection: Projection::Mercator,
+            show_atmos: false,
             last_draw_type: DrawType::Null,
         }
     }
         };
     }
 
+    pub fn toggle_atmosphere(&mut self) {
+        self.show_atmos = !self.show_atmos;
+    }
+
     fn draw_mercator_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
         -> Result<usize, usize>
     {
         )
     }
 
+    fn draw_atmos(&mut self, cx: &mut Context) {
+        if self.last_draw_type != DrawType::Atmos {
+            self.last_draw_type = DrawType::Atmos;
+            self.atmos_layer.prepare_draw(cx);
+        }
+
+        self.atmos_layer.draw(
+            cx,
+            &self.map_view,
+        )
+    }
+
     /// Returns `Err` when tile cache is too small for this view.
     /// Returns the number of OpenGL draw calls, which can be decreased to `1` by increasing the
     /// size of the tile atlas.
                 if !self.marker_layer.is_empty() {
                     self.draw_ortho_marker(cx);
                 }
+                if self.show_atmos {
+                    self.draw_atmos(cx);
+                }
                 ret
             },
         }

src/orthografic_view.rs

         tiles
     }
 
+    pub fn radius_physical_pixels(map_view: &MapView) -> f64 {
+        2.0f64.powf(map_view.zoom) * (FRAC_1_PI * map_view.tile_size as f64)
+    }
+
     pub fn transformation_matrix(map_view: &MapView) -> Matrix3<f64> {
         let (scale_x, scale_y) = {
-            let factor = 2.0f64.powf(map_view.zoom) *
-                (FRAC_1_PI * map_view.tile_size as f64);
-            (factor / map_view.width, factor / map_view.height)
+            let radius = Self::radius_physical_pixels(map_view);
+            (radius / map_view.width, radius / map_view.height)
         };
 
         let scale_mat: Matrix3<f64> = Matrix3::from_cols(

src/program.rs

     id: u32,
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct UniformId {
+    id: i32,
+}
+
 impl ProgramId {
     /// Returns an invalid `ProgramId`.
     pub fn invalid() -> Self {
         }
     }
 
+
+    pub fn get_uniform_id(&mut self, cx: &mut Context, uniform_name: &CStr) -> Option<UniformId> {
+        cx.use_program(self.program_id);
+        let loc: i32 = unsafe {
+            cx.gl.GetUniformLocation(self.program_id.index(), uniform_name.as_ptr() as *const _)
+        };
+        check_gl_errors!(cx);
+
+        if loc == -1 {
+            None
+        } else {
+            Some(UniformId { id: loc })
+        }
+    }
+
+    pub fn set_uniform_2f(&mut self, cx: &mut Context, uniform_id: UniformId, v0: f32, v1: f32) {
+        cx.use_program(self.program_id);
+        unsafe {
+            cx.gl.Uniform2f(uniform_id.id, v0, v1);
+        };
+    }
+
     //TODO rename function or integrate into new()
     pub fn add_attribute(
         &mut self,