Restructure OpenGL context sharing

Program, Buffer, Texture... structs no longer store a reference to a
Context. Now it has to be passed explicitly to all methods that mutate
the OpenGL state. This enables caching the state and removing redundant
calls to gl* functions.

src/buffer.rs

 
 
 #[derive(Clone, Debug)]
-pub struct Buffer<'a> {
-    cx: &'a Context,
+pub struct Buffer {
     buffer_obj: u32,
     num_elements: usize,
 }
     }
 }
 
-impl<'a> Buffer<'a> {
-    pub fn new(cx: &'a Context, vertex_data: &[f32], num_elements: usize) -> Buffer<'a> {
+impl Buffer {
+    pub fn new(cx: &mut Context, vertex_data: &[f32], num_elements: usize) -> Buffer {
         let mut buffer_obj = 0_u32;
 
         unsafe {
         }
 
         Buffer {
-            cx,
             buffer_obj,
             num_elements,
         }
     }
 
-    pub fn set_data(&mut self, vertex_data: &[f32], num_elements: usize) {
+    pub fn set_data(&mut self, cx: &mut Context, vertex_data: &[f32], num_elements: usize) {
         unsafe {
-            self.cx.gl.BufferData(context::gl::ARRAY_BUFFER,
+            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) {
+    pub fn bind(&self, cx: &mut Context) {
         unsafe {
-            self.cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, self.buffer_obj);
+            cx.gl.BindBuffer(context::gl::ARRAY_BUFFER, self.buffer_obj);
         }
     }
 
-    pub fn draw(&self, mode: DrawMode) {
+    pub fn draw(&self, cx: &mut Context, mode: DrawMode) {
         unsafe {
-            self.cx.gl.DrawArrays(
+            cx.gl.DrawArrays(
                 mode.to_gl_enum(),
                 0,
                 self.num_elements as context::gl::types::GLsizei);

src/main.rs

     let window = gl_window.window();
 
     let _ = unsafe { gl_window.make_current() };
-    let cx = context::Context::from_gl_window(&gl_window);
+    let mut cx = context::Context::from_gl_window(&gl_window);
 
     let mut map = {
         let proxy = events_loop.create_proxy();
 
         map_view_gl::MapViewGl::new(
-            &cx,
+            &mut cx,
             window.get_inner_size().unwrap(),
             move || { proxy.wakeup().unwrap(); },
             config.use_network(),
 
         if let Action::Resize(w, h) = action {
             gl_window.resize(w, h);
-            map.set_viewport_size(w, h);
+            map.set_viewport_size(&mut cx, w, h);
         }
 
         let redraw = match action {
             if !map.viewport_in_map() {
                 cx.clear_color((0.2, 0.2, 0.2, 1.0));
             }
-            let draw_result = map.draw(sources.current());
+            let draw_result = map.draw(&mut cx, sources.current());
 
             let draw_dur = draw_start.elapsed();
 
 
             let _ = gl_window.swap_buffers();
 
+            last_draw = Instant::now();
+
             //TODO increase atlas size earlier to avoid excessive copying to the GPU
             //TODO increase max tile cache size?
             if increase_atlas_size_possible {
                     Err(x) => x,
                 };
                 if draws > 1 {
-                    increase_atlas_size_possible = map.increase_atlas_size().is_ok();
+                    increase_atlas_size_possible = map.increase_atlas_size(&mut cx).is_ok();
                 }
             }
 
-            last_draw = Instant::now();
-
             debug!("draw: {} sec (est {} sec)", dur_to_sec(draw_dur), dur_to_sec(est_draw_dur));
 
             est_draw_dur = if draw_dur > est_draw_dur {

src/map_view_gl.rs

 const MAX_ZOOM_LEVEL: f64 = 22.0;
 
 #[derive(Debug)]
-pub struct MapViewGl<'a> {
-    cx: &'a Context,
-    program: Program<'a>,
-    buf: Buffer<'a>,
+pub struct MapViewGl {
+    program: Program,
+    buf: Buffer,
     viewport_size: (u32, u32),
     map_view: MapView,
     tile_cache: TileCache,
-    tile_atlas: TileAtlas<'a>,
+    tile_atlas: TileAtlas,
 }
 
-impl<'a> MapViewGl<'a> {
+impl MapViewGl {
     pub fn new<F>(
-        cx: &Context,
+        cx: &mut Context,
         initial_size: (u32, u32),
         update_func: F,
         use_network: bool,
         let buf = Buffer::new(cx, &[], 0);
         check_gl_errors!(cx);
 
-        program.add_texture(&tex, CStr::from_bytes_with_nul(b"tex_map\0").unwrap());
+        program.add_texture(cx, &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);
-        program.add_attribute(CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(), 2, 8, 2);
-        program.add_attribute(CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(), 4, 8, 4);
+        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);
         check_gl_errors!(cx);
 
-        program.before_render();
+        program.before_render(cx);
 
         let mut map_view = MapView::with_filling_zoom(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
 
         }
 
         MapViewGl {
-            cx,
             program,
             buf,
             viewport_size: initial_size,
             map_view,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
-            tile_atlas: TileAtlas::new(tex, 256, use_async),
+            tile_atlas: TileAtlas::new(cx, tex, 256, use_async),
         }
     }
 
-    pub fn set_viewport_size(&mut self, width: u32, height: u32) {
+    pub fn set_viewport_size(&mut self, cx: &mut Context, width: u32, height: u32) {
         self.viewport_size = (width, height);
         self.map_view.set_size(f64::from(width), f64::from(height));
-        self.cx.set_viewport(0, 0, width, height);
+        cx.set_viewport(0, 0, width, height);
     }
 
     pub fn viewport_in_map(&self) -> bool {
         self.map_view.viewport_in_map()
     }
 
-    pub fn increase_atlas_size(&mut self) -> Result<(), ()> {
-        self.tile_atlas.double_texture_size()
+    pub fn increase_atlas_size(&mut self, cx: &mut Context) -> Result<(), ()> {
+        self.tile_atlas.double_texture_size(cx)
     }
 
     /// 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.
-    pub fn draw(&mut self, source: &TileSource) -> Result<usize, usize> {
+    pub fn draw(&mut self, cx: &mut Context, source: &TileSource) -> Result<usize, usize> {
         self.tile_cache.set_view_location(View {
             source_id: source.id(),
             zoom: self.map_view.tile_zoom(),
         loop {
             let (textured_visible_tiles, remainder_opt, used_tiles) = {
                 self.tile_atlas.textured_visible_tiles(
+                    cx,
                     remainder,
                     max_tiles_to_use,
                     source,
                 vertex_data.extend(&minmax);
             }
 
-            self.buf.set_data(&vertex_data, vertex_data.len() / 4);
-            self.buf.draw(DrawMode::Triangles);
+            self.buf.set_data(cx, &vertex_data, vertex_data.len() / 4);
+            self.buf.draw(cx, DrawMode::Triangles);
 
             num_draws += 1;
 

src/program.rs

 
 
 #[derive(Clone, Debug)]
-pub struct Program<'a> {
-    cx: &'a ::context::Context,
+pub struct Program {
     vert_obj: u32,
     frag_obj: u32,
     program_obj: u32,
     id: u32,
 }
 
-impl<'a> Program<'a> {
-    pub fn from_paths<P: AsRef<Path>>(cx: &'a Context, vert_path: P, frag_path: P) -> Result<Program<'a>, String> {
+impl Program {
+    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: &'a Context, vert_src: &[u8], frag_src: &[u8]) -> Result<Program<'a>, 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);
             };
 
             Ok(Program {
-                cx,
                 vert_obj,
                 frag_obj,
                 program_obj,
         }
     }
 
-    pub fn add_texture(&mut self, texture: &Texture, uniform_name: &CStr) {
+    pub fn add_texture(&mut self, cx: &mut Context, texture: &Texture, uniform_name: &CStr) {
         //TODO store reference to texture
         unsafe {
-            let tex_loc = self.cx.gl.GetUniformLocation(self.program_obj, uniform_name.as_ptr() as *const _);
-            check_gl_errors!(self.cx);
+            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);
         }
     }
 
-    pub fn add_attribute(&mut self, name: &CStr, number_components: u32, stride: usize, offset: usize) {
+    pub fn add_attribute(&mut self, cx: &mut Context, name: &CStr, number_components: u32, stride: usize, offset: usize) {
         unsafe {
-            let attrib_id = self.cx.gl.GetAttribLocation(self.program_obj, name.as_ptr() as *const _);
-            self.cx.gl.VertexAttribPointer(
+            let attrib_id = cx.gl.GetAttribLocation(self.program_obj, 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 _);
-            self.cx.gl.EnableVertexAttribArray(attrib_id as u32);
+            cx.gl.EnableVertexAttribArray(attrib_id as u32);
         }
-        check_gl_errors!(self.cx);
+        check_gl_errors!(cx);
     }
 
-    pub fn before_render(&self) {
+    pub fn before_render(&self, cx: &mut Context) {
         unsafe {
-            //self.cx.gl.UseProgram(self.program_obj);
+            //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);
+                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);
             }
         }
     }

src/texture.rs

 use std::os::raw::c_void;
 
 #[derive(Clone, Debug)]
-pub struct Texture<'a> {
-    cx: &'a Context,
+pub struct Texture {
     texture_obj: u32,
     width: u32,
     height: u32,
     pub(crate) id: u32,
 }
 
-impl<'a> Texture<'a> {
-    pub fn new(cx: &'a Context, img: &image::DynamicImage) -> Result<Texture<'a>, ()> {
+impl Texture {
+    pub fn new(cx: &mut Context, img: &image::DynamicImage) -> Result<Texture, ()> {
         let format = match *img {
             image::ImageRgb8(_) => TextureFormat::Rgb8,
             image::ImageRgba8(_) => TextureFormat::Rgba8,
         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> {
+    pub fn empty(cx: &mut Context, width: u32, height: u32, format: TextureFormat) -> Texture {
         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> {
+    pub fn from_bytes(cx: &mut Context, width: u32, height: u32, format: TextureFormat, data: &[u8]) -> Texture {
         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> {
+    fn from_ptr(cx: &mut Context, width: u32, height: u32, format: TextureFormat, data_ptr: *const c_void) -> Texture {
         let mut texture_obj = 0_u32;
         unsafe {
             cx.gl.GenTextures(1, &mut texture_obj);
         }
 
         Texture {
-            cx,
             texture_obj,
             width,
             height,
         }
     }
 
-    pub fn sub_image(&mut self, x: i32, y: i32, img: &image::DynamicImage) {
+    pub fn sub_image(&mut self, cx: &mut Context, x: i32, y: i32, img: &image::DynamicImage) {
         let format = match *img {
             image::ImageRgb8(_) => TextureFormat::Rgb8,
             image::ImageRgba8(_) => TextureFormat::Rgba8,
         };
 
         unsafe {
-            self.cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
-            self.cx.gl.TexSubImage2D(
+            cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
+            cx.gl.TexSubImage2D(
                 context::gl::TEXTURE_2D,
                 0, // level
                 x, // x offset
         }
     }
 
-    pub fn resize(&mut self, width: u32, height: u32) {
+    pub fn resize(&mut self, cx: &mut Context, width: u32, height: u32) {
         unsafe {
-            self.cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
-            self.cx.gl.TexImage2D(
+            cx.gl.BindTexture(context::gl::TEXTURE_2D, self.texture_obj);
+            cx.gl.TexImage2D(
                 context::gl::TEXTURE_2D,
                 0, // level
                 self.format.to_gl_enum() as i32,
     pub fn height(&self) -> u32 {
         self.height
     }
-
-    pub fn context(&self) -> &Context {
-        self.cx
-    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]

src/tile_atlas.rs

+use context::Context;
 use coord::{ScreenRect, SubTileCoord, TileCoord, TextureRect};
 use image;
 use linked_hash_map::LinkedHashMap;
 }
 
 #[derive(Clone, Debug)]
-pub struct TileAtlas<'a> {
-    texture: Texture<'a>,
+pub struct TileAtlas {
+    texture: Texture,
     tile_size: u32,
     slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
     tile_to_slot: HashMap<Tile, CacheSlot>,
     use_async: bool,
 }
 
-impl<'a> TileAtlas<'a> {
-    fn init(&mut self) {
+impl TileAtlas {
+    fn init(&mut self, cx: &mut Context) {
         // add tile for default slot
         {
             let img = image::load_from_memory(
                 include_bytes!("../img/no_tile.png"),
             ).unwrap();
-            self.texture.sub_image(0, 0, &img);
+            self.texture.sub_image(cx, 0, 0, &img);
         }
 
         let slots_x = self.texture.width() / self.tile_size;
         self.tile_to_slot.reserve(num_slots);
     }
 
-    pub fn new(tex: Texture<'a>, tile_size: u32, use_async: bool) -> Self {
+    pub fn new(cx: &mut Context, tex: Texture, tile_size: u32, use_async: bool) -> Self {
         let mut atlas = TileAtlas {
             texture: tex,
             tile_size,
             use_async,
         };
 
-        atlas.init();
+        atlas.init(cx);
         atlas
     }
 
-    pub fn double_texture_size(&mut self) -> Result<(), ()> {
-        let max_size = self.texture.context().max_texture_size() as u32;
+    pub fn double_texture_size(&mut self, cx: &mut Context) -> Result<(), ()> {
+        let max_size = cx.max_texture_size() as u32;
 
         let new_width = self.texture.width() * 2;
         let new_height = self.texture.height() * 2;
 
         if new_width <= max_size && new_height <= max_size {
-            self.texture.resize(new_width, new_height);
+            self.texture.resize(cx, new_width, new_height);
 
             // remove old entries, initialize texture
-            self.init();
+            self.init(cx);
 
             info!("new atlas size {}x{}", new_width, new_height);
 
         CacheSlot { x: 0, y: 0 }
     }
 
-    pub fn store(&mut self, tile_coord: TileCoord, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
+    pub fn store(&mut self, cx: &mut Context, tile_coord: TileCoord, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
         let mut remove_tile = None;
         let tile = Tile::new(tile_coord, source.id());
 
                     remove_tile = old_tile;
 
                     self.texture.sub_image(
+                        cx,
                         (slot.x * self.tile_size) as i32,
                         (slot.y * self.tile_size) as i32,
                         img,
     /// the number of used tiles is returned as an `usize`.
     pub fn textured_visible_tiles<'b>(
         &mut self,
+        cx: &mut Context,
         visible_tiles: &'b [VisibleTile],
         max_tiles_to_use: usize,
         source: &TileSource,
                 return (tvt, Some(&visible_tiles[i..]), used_slots);
             }
 
-            if let Some(slot) = self.store(vt.tile, source, cache, true) {
+            if let Some(slot) = self.store(cx, vt.tile, source, cache, true) {
                 let tex_rect = self.slot_to_texture_rect(slot);
                 used_slots += 1;
                 tvt.push(
                 // look for cached tiles in lower zoom layers
                 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) {
+                        if let Some(slot) = self.store(cx, parent_tile, source, cache, false) {
                             used_slots += 1;
                             tex_sub_rect = self.subslot_to_texture_rect(slot, sub_coord);
                             tex_rect = self.slot_to_texture_rect(slot);
 
                 // look for cached tiles in higher zoom layers
                 for &(child_tile, child_sub_coord) in &vt.tile.children() {
-                    if let Some(slot) = self.store(child_tile, source, cache, false) {
+                    if let Some(slot) = self.store(cx, child_tile, source, cache, false) {
                         used_slots += 1;
                         let tex_rect = self.slot_to_texture_rect(slot);