Cache enabled vertex attributes, store params

* Cache the enabled vertex attributes in `Context`
* The vertex attribute parameters (offset, stride, ...) are not cached,
  yet
* Store parameters as `VertexAttribParams` in `Program`

src/buffer.rs

 use ::context;
 use context::Context;
+use program::Program;
 use std::mem;
 
 
         self.num_elements = num_elements;
     }
 
-    pub fn draw(&self, cx: &mut Context, mode: DrawMode) {
+    pub fn draw(&self, cx: &mut Context, program: &Program, mode: DrawMode) {
         cx.bind_buffer(self.buffer_id);
+        cx.use_program(program.id());
+        program.enable_vertex_attribs(cx);
         unsafe {
             cx.gl.DrawArrays(
                 mode.to_gl_enum(),
                 self.num_elements as context::gl::types::GLsizei);
         }
     }
+
+    pub fn id(&self) -> BufferId {
+        self.buffer_id
+    }
 }

src/context.rs

 use glutin::GlContext;
 use glutin;
 use program::ProgramId;
+use std::collections::HashSet;
 use std::ffi::CStr;
 use std::mem;
+use vertex_attrib::VertexAttribLoc;
 
 pub(crate) mod gl {
     #![allow(unknown_lints)]
     next_free_texture_unit: TextureUnit,
     active_program: ProgramId,
     active_buffer: BufferId,
+    active_attribs: HashSet<VertexAttribLoc>,
 }
 
 impl ::std::fmt::Debug for Context {
             next_free_texture_unit: TextureUnit(0),
             active_program: ProgramId::invalid(),
             active_buffer: BufferId::invalid(),
+            active_attribs: HashSet::new(),
         };
 
         // Initialize a vertex array object (VAO) if the current OpenGL context supports it. VAOs are
             self.active_buffer = buf;
         }
     }
+
+    /// Enable all vertex attributes given by their location and disable all other vertex
+    /// attributes.
+    //TODO group attribs by program
+    pub fn enable_vertex_attribs(&mut self, attribs: &[VertexAttribLoc]) {
+        let new_set: HashSet<_> = attribs.iter().cloned().collect();
+
+        unsafe {
+            for old_attrib in self.active_attribs.difference(&new_set) {
+                self.gl.DisableVertexAttribArray(old_attrib.index());
+            }
+
+            for new_attrib in new_set.difference(&self.active_attribs) {
+                self.gl.EnableVertexAttribArray(new_attrib.index());
+            }
+        }
+
+        self.active_attribs = new_set;
+    }
+
+    pub fn enable_vertex_attrib(&mut self, attrib: VertexAttribLoc) {
+        if !self.active_attribs.contains(&attrib) {
+            unsafe {
+                self.gl.EnableVertexAttribArray(attrib.index());
+            }
+            self.active_attribs.insert(attrib);
+        }
+    }
+
+    /// Print status of vector attributes.
+    pub fn debug_attribs(&self) {
+        unsafe {
+            let mut max_attribs = 0i32;
+            self.gl.GetIntegerv(gl::MAX_VERTEX_ATTRIBS, &mut max_attribs as *mut _);
+
+            for index in 0..(max_attribs as u32) {
+                let mut enabled = 0i32;
+                self.gl.GetVertexAttribiv(index, gl::VERTEX_ATTRIB_ARRAY_ENABLED, &mut enabled as *mut _);
+                let enabled: bool = enabled != 0;
+                println!("attribute {} enabled: {}", index, enabled);
+            }
+        }
+    }
 }

src/main.rs

 extern crate toml;
 
 pub mod args;
-#[macro_use]
-pub mod context;
 pub mod buffer;
 pub mod config;
+#[macro_use]
+pub mod context;
 pub mod coord;
 pub mod map_view;
 pub mod map_view_gl;
 pub mod tile_loader;
 pub mod tile_source;
 pub mod url_template;
+pub mod vertex_attrib;
 
 use coord::ScreenCoord;
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};

src/map_view_gl.rs

 use map_view::MapView;
 use program::Program;
 use texture::{Texture, TextureFormat};
-use tile_cache::TileCache;
 use tile_atlas::TileAtlas;
+use tile_cache::TileCache;
 use tile_source::TileSource;
+use vertex_attrib::VertexAttribParams;
 
 
 const MIN_ZOOM_LEVEL: f64 = 0.0;
 
 #[derive(Debug)]
 pub struct MapViewGl {
-    program: Program,
-    buf: Buffer,
-    viewport_size: (u32, u32),
     map_view: MapView,
+    viewport_size: (u32, u32),
+    tile_program: Program,
+    tile_buffer: Buffer,
     tile_cache: TileCache,
     tile_atlas: TileAtlas,
 }
         ) -> MapViewGl
         where F: Fn() + Sync + Send + 'static,
     {
-        let mut program = Program::new(
+        let tile_size = 256;
+
+        let mut map_view = MapView::with_filling_zoom(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;
+        }
+
+        let tile_buffer = Buffer::new(cx, &[], 0);
+        check_gl_errors!(cx);
+        cx.bind_buffer(tile_buffer.id());
+
+        let mut tile_program = Program::new(
             cx,
             include_bytes!("../shader/map.vert"),
             include_bytes!("../shader/map.frag"),
         ).unwrap();
         check_gl_errors!(cx);
 
-        let tile_size = 256;
-
         let atlas_size = {
             let default_size = 2048;
             let max_size = cx.max_texture_size() as u32;
             }
         };
 
-        let tex = Texture::empty(cx, atlas_size, atlas_size, TextureFormat::Rgb8);
-        check_gl_errors!(cx);
-
-        let buf = Buffer::new(cx, &[], 0);
+        let atlas_tex = Texture::empty(cx, atlas_size, atlas_size, TextureFormat::Rgb8);
         check_gl_errors!(cx);
 
-        program.add_texture(cx, &tex, CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
+        tile_program.add_texture(cx, &atlas_tex, CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
         check_gl_errors!(cx);
 
-        program.add_attribute(cx, CStr::from_bytes_with_nul(b"position\0").unwrap(), 2, 8, 0);
-        program.add_attribute(cx, CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(), 2, 8, 2);
-        program.add_attribute(cx, CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(), 4, 8, 4);
+        tile_program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"position\0").unwrap(),
+            &VertexAttribParams::new(2, 8, 0)
+        );
+        tile_program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(),
+            &VertexAttribParams::new(2, 8, 2)
+        );
+        tile_program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(),
+            &VertexAttribParams::new(4, 8, 4)
+        );
         check_gl_errors!(cx);
 
-        let mut map_view = MapView::with_filling_zoom(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_program.enable_vertex_attribs(cx);
+        tile_program.set_vertex_attribs(cx, &tile_buffer);
 
         MapViewGl {
-            program,
-            buf,
-            viewport_size: initial_size,
             map_view,
+            viewport_size: initial_size,
+            tile_program,
+            tile_buffer,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
-            tile_atlas: TileAtlas::new(cx, tex, 256, use_async),
+            tile_atlas: TileAtlas::new(cx, atlas_tex, 256, use_async),
         }
     }
 
                 vertex_data.extend(&minmax);
             }
 
-            self.buf.set_data(cx, &vertex_data, vertex_data.len() / 4);
-            self.buf.draw(cx, DrawMode::Triangles);
+            self.tile_buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
+            self.tile_buffer.draw(cx, &self.tile_program, DrawMode::Triangles);
 
             num_draws += 1;
 

src/program.rs

 use ::context;
+use buffer::Buffer;
 use context::Context;
 use std::ffi::CStr;
 use std::fs::File;
 use std::mem;
 use std::path::Path;
 use texture::Texture;
+use vertex_attrib::{VertexAttribLoc, VertexAttribParams};
 
 
 #[derive(Clone, Debug)]
     vert_obj: u32,
     frag_obj: u32,
     program_id: ProgramId,
+    attrib_locs: Vec<VertexAttribLoc>,
+    attrib_params: Vec<VertexAttribParams>,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 }
 
 impl Program {
-    pub fn from_paths<P: AsRef<Path>>(cx: &mut Context, vert_path: P, frag_path: P) -> Result<Program, String> {
+    pub fn from_paths<P: AsRef<Path>>(
+        cx: &mut Context,
+        vert_path: P,
+        frag_path: P,
+    ) -> Result<Program, String> {
         let vert_src = {
             let file = File::open(&vert_path)
                 .map_err(|e| format!("{}", e))?;
         Self::new(cx, &vert_src, &frag_src)
     }
 
-    pub fn new(cx: &mut Context, vert_src: &[u8], frag_src: &[u8]) -> Result<Program, String> {
+    pub fn new(
+        cx: &mut Context,
+        vert_src: &[u8],
+        frag_src: &[u8],
+    ) -> Result<Program, String> {
         unsafe {
             let vert_obj = {
                 let vert_obj = cx.gl.CreateShader(context::gl::VERTEX_SHADER);
             cx.use_program(program_id);
             check_gl_errors!(cx);
 
-            Ok(Program {
-                vert_obj,
-                frag_obj,
-                program_id,
-            })
+            Ok(
+                Program {
+                    vert_obj,
+                    frag_obj,
+                    program_id,
+                    attrib_locs: vec![],
+                    attrib_params: vec![],
+                }
+            )
         }
     }
 
         }
     }
 
-    pub fn add_attribute(&mut self, cx: &mut Context, name: &CStr, number_components: u32, stride: usize, offset: usize) {
+    //TODO rename function or integrate into new()
+    pub fn add_attribute(
+        &mut self,
+        cx: &mut Context,
+        name: &CStr,
+        params: &VertexAttribParams,
+    ) {
         cx.use_program(self.program_id);
-        unsafe {
-            let attrib_id = cx.gl.GetAttribLocation(self.program_id.index(), name.as_ptr() as *const _);
-            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 _);
-            cx.gl.EnableVertexAttribArray(attrib_id as u32);
+
+        let attrib_loc = unsafe {
+            cx.gl.GetAttribLocation(self.program_id.index(), name.as_ptr() as *const _)
+        };
+        if attrib_loc < 0 {
+            panic!("Attribute location not found: {:?}", name);
         }
+        let attrib_loc = VertexAttribLoc::new(attrib_loc as u32);
         check_gl_errors!(cx);
+
+        self.attrib_locs.push(attrib_loc);
+        self.attrib_params.push(params.clone());
+    }
+
+    pub fn enable_vertex_attribs(&self, cx: &mut Context) {
+        cx.enable_vertex_attribs(&self.attrib_locs)
+    }
+
+    //TODO use separate buffer for each attribute
+    pub fn set_vertex_attribs(
+        &self,
+        cx: &mut Context,
+        buffer: &Buffer,
+    ) {
+        cx.bind_buffer(buffer.id());
+        for (params, loc) in self.attrib_params.iter().zip(self.attrib_locs.iter()) {
+            params.set(cx, *loc);
+        }
     }
 
     pub fn id(&self) -> ProgramId {

src/vertex_attrib.rs

+use ::context;
+use context::Context;
+use std::mem;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct VertexAttribLoc(u32);
+
+impl VertexAttribLoc {
+    pub fn new(location: u32) -> VertexAttribLoc {
+        VertexAttribLoc(location)
+    }
+
+    pub fn index(&self) -> u32 {
+        self.0
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct VertexAttribParams {
+    pub number_components: u32,
+    pub stride: usize,
+    pub offset: usize,
+}
+
+impl VertexAttribParams {
+    pub fn new(
+        number_components: u32,
+        stride: usize,
+        offset: usize,
+    ) -> VertexAttribParams {
+        VertexAttribParams {
+            number_components,
+            stride,
+            offset,
+        }
+    }
+
+    pub fn set(&self, cx: &mut Context, loc: VertexAttribLoc) {
+        unsafe {
+            cx.gl.VertexAttribPointer(
+                loc.0,
+                self.number_components as i32, // size
+                context::gl::FLOAT, // type
+                0, // normalized
+                (self.stride * mem::size_of::<f32>()) as context::gl::types::GLsizei,
+                (self.offset * mem::size_of::<f32>()) as *const () as *const _,
+            );
+        }
+    }
+}