Cache active texture unit, assign unit to texture

Each Texture is bound to a unique texture unit (glBindTexture is called
only once). Context keeps track of the current active texture unit and
reduces the number of glActiveTexture calls to a minimum.

src/context.rs

     include!(concat!(env!("OUT_DIR"), "/gles_bindings.rs"));
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct TextureUnit(u32);
+
+impl TextureUnit {
+    pub fn index(&self) -> u32 {
+        self.0
+    }
+}
+
 #[derive(Clone)]
 pub struct Context {
     pub(crate) gl: gl::Gl,
+    active_texture_unit: TextureUnit,
+    next_free_texture_unit: TextureUnit,
 }
 
 impl ::std::fmt::Debug for Context {
 impl Context {
     pub fn from_gl_window(window: &glutin::GlWindow) -> Context {
         let gl = gl::Gl::load_with(|ptr| window.get_proc_address(ptr) as *const _);
-        let cx = Context { gl };
+        let cx = Context {
+            gl,
+            /// Initial active texture unit is supposed to be GL_TEXTURE0
+            active_texture_unit: TextureUnit(0),
+            next_free_texture_unit: TextureUnit(0),
+        };
 
         // Initialize a vertex array object (VAO) if the current OpenGL context supports it. VAOs are
         // not OpenGL ES 2.0 compatible, but are required for rendering with a core context.
             );
         }
     }
+
+    pub fn set_active_texture_unit(&mut self, unit: TextureUnit) {
+        if unit != self.active_texture_unit {
+            unsafe {
+                self.gl.ActiveTexture(gl::TEXTURE0 + unit.0);
+            }
+        }
+        self.active_texture_unit = unit;
+    }
+
+    pub fn occupy_free_texture_unit(&mut self) -> TextureUnit {
+        let tu = self.next_free_texture_unit;
+
+        //TODO check against max number of texture units
+        //TODO add a way to free texture units
+        self.next_free_texture_unit = TextureUnit(self.next_free_texture_unit.0 + 1);
+
+        tu
+    }
 }

src/map_view_gl.rs

         program.add_attribute(cx, CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(), 4, 8, 4);
         check_gl_errors!(cx);
 
-        program.before_render(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 {

src/program.rs

 use std::io::Read;
 use std::mem;
 use std::path::Path;
-use texture::{Texture, TextureId};
+use texture::Texture;
 
 
 #[derive(Clone, Debug)]
     vert_obj: u32,
     frag_obj: u32,
     program_obj: u32,
-    tex_ids: Vec<TextureId>,
-    tex_locations: Vec<i32>,
 }
 
 #[derive(Clone, Debug)]
                 vert_obj,
                 frag_obj,
                 program_obj,
-                tex_ids: vec![],
-                tex_locations: vec![],
             })
         }
     }
             let tex_loc = cx.gl.GetUniformLocation(self.program_obj, uniform_name.as_ptr() as *const _);
             check_gl_errors!(cx);
 
-            self.tex_ids.push(texture.id());
-            self.tex_locations.push(tex_loc);
+            cx.gl.Uniform1i(tex_loc, texture.unit().index() as i32);
         }
     }
 
         check_gl_errors!(cx);
     }
 
-    pub fn before_render(&self, cx: &mut Context) {
-        unsafe {
-            //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() {
-                cx.gl.ActiveTexture(context::gl::TEXTURE0 + i as u32);
-                cx.gl.BindTexture(context::gl::TEXTURE_2D, tex_id.id);
-                cx.gl.Uniform1i(tex_loc, i as i32);
-            }
-        }
-    }
-
     pub fn id(&self) -> ProgramId {
         ProgramId {
             id: self.program_obj,

src/texture.rs

 use ::context;
 use ::image;
-use context::Context;
+use context::{Context, TextureUnit};
 use image::GenericImage;
 use std::os::raw::c_void;
 
 #[derive(Clone, Debug)]
 pub struct Texture {
     texture_obj: u32,
+    texture_unit: TextureUnit,
     width: u32,
     height: u32,
     format: TextureFormat,
 
     fn from_ptr(cx: &mut Context, width: u32, height: u32, format: TextureFormat, data_ptr: *const c_void) -> Texture {
         let mut texture_obj = 0_u32;
+
+        let texture_unit = cx.occupy_free_texture_unit();
+        cx.set_active_texture_unit(texture_unit);
+
         unsafe {
             cx.gl.GenTextures(1, &mut texture_obj);
             cx.gl.BindTexture(context::gl::TEXTURE_2D, texture_obj);
 
         Texture {
             texture_obj,
+            texture_unit,
             width,
             height,
             format,
             _ => return,
         };
 
+        cx.set_active_texture_unit(self.texture_unit);
         unsafe {
-            cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
             cx.gl.TexSubImage2D(
                 context::gl::TEXTURE_2D,
                 0, // level
     }
 
     pub fn resize(&mut self, cx: &mut Context, width: u32, height: u32) {
+        cx.set_active_texture_unit(self.texture_unit);
         unsafe {
-            cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
             cx.gl.TexImage2D(
                 context::gl::TEXTURE_2D,
                 0, // level
         }
     }
 
+    pub fn unit(&self) -> TextureUnit {
+        self.texture_unit
+    }
+
     pub fn width(&self) -> u32 {
         self.width
     }