context: Cache active buffer

This reduces calls to glUseBuffer.

src/buffer.rs

 use std::mem;
 
 
+//TODO rename Buffer -> ArrayBuffer?
 #[derive(Clone, Debug)]
 pub struct Buffer {
-    buffer_obj: u32,
+    buffer_id: BufferId,
     num_elements: usize,
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct BufferId {
+    id: u32,
+}
+
+impl BufferId {
+    /// Returns an invalid `BufferId`.
+    pub fn invalid() -> Self {
+        BufferId{ id: 0 }
+    }
+
+    pub fn index(&self) -> u32 {
+        self.id
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum DrawMode {
     Triangles,
 
 impl Buffer {
     pub fn new(cx: &mut Context, vertex_data: &[f32], num_elements: usize) -> Buffer {
-        let mut buffer_obj = 0_u32;
+        let mut buffer_id = BufferId { id: 0 };
 
         unsafe {
-            cx.gl.GenBuffers(1, &mut buffer_obj);
-            cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, buffer_obj);
+            cx.gl.GenBuffers(1, &mut buffer_id.id);
+            cx.bind_buffer(buffer_id);
             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 _,
         }
 
         Buffer {
-            buffer_obj,
+            buffer_id,
             num_elements,
         }
     }
 
     pub fn set_data(&mut self, cx: &mut Context, vertex_data: &[f32], num_elements: usize) {
+        cx.bind_buffer(self.buffer_id);
         unsafe {
             cx.gl.BufferData(context::gl::ARRAY_BUFFER,
                                   (vertex_data.len() * mem::size_of::<f32>()) as context::gl::types::GLsizeiptr,
         self.num_elements = num_elements;
     }
 
-    pub fn bind(&self, cx: &mut Context) {
-        unsafe {
-            cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, self.buffer_obj);
-        }
-    }
-
     pub fn draw(&self, cx: &mut Context, mode: DrawMode) {
+        cx.bind_buffer(self.buffer_id);
         unsafe {
             cx.gl.DrawArrays(
                 mode.to_gl_enum(),

src/context.rs

+use buffer::BufferId;
 use glutin::GlContext;
 use glutin;
 use program::ProgramId;
     active_texture_unit: TextureUnit,
     next_free_texture_unit: TextureUnit,
     active_program: ProgramId,
+    active_buffer: BufferId,
 }
 
 impl ::std::fmt::Debug for Context {
             active_texture_unit: TextureUnit(0),
             next_free_texture_unit: TextureUnit(0),
             active_program: ProgramId::invalid(),
+            active_buffer: BufferId::invalid(),
         };
 
         // Initialize a vertex array object (VAO) if the current OpenGL context supports it. VAOs are
             self.active_program = prog;
         }
     }
+
+    pub fn bind_buffer(&mut self, buf: BufferId) {
+        if buf != self.active_buffer {
+            unsafe {
+                self.gl.BindBuffer(gl::ARRAY_BUFFER, buf.index());
+            }
+            self.active_buffer = buf;
+        }
+    }
 }