Extract code into marker_layer module

src/main.rs

@@ -23,6 +23,7 @@ pub mod context;
 pub mod coord;
 pub mod map_view;
 pub mod map_view_gl;
+pub mod marker_layer;
 pub mod program;
 pub mod search;
 pub mod texture;

src/map_view_gl.rs

@@ -1,10 +1,9 @@
 use ::std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
-use cgmath::{Matrix3, Point2, Transform, vec2, vec3};
 use context::Context;
-use coord::{MapCoord, ScreenCoord, ScreenRect, View};
-use image;
+use coord::{MapCoord, ScreenCoord, View};
 use map_view::MapView;
+use marker_layer::MarkerLayer;
 use program::Program;
 use texture::{Texture, TextureFormat};
 use tile_atlas::TileAtlas;
@@ -24,10 +23,7 @@ pub struct MapViewGl {
     tile_buffer: Buffer,
     tile_cache: TileCache,
     tile_atlas: TileAtlas,
-    marker_buffer: Buffer,
-    marker_program: Program,
-    marker_tex: Texture,
-    markers: Vec<MapCoord>,
+    marker_layer: MarkerLayer,
     last_draw_type: DrawType,
 }
 
@@ -104,38 +100,6 @@ impl MapViewGl {
         );
         check_gl_errors!(cx);
 
-
-        let marker_buffer = Buffer::new(cx, &[], 0);
-        cx.bind_buffer(marker_buffer.id());
-        check_gl_errors!(cx);
-
-        let mut marker_program = Program::new(
-            cx,
-            include_bytes!("../shader/marker.vert"),
-            include_bytes!("../shader/marker.frag"),
-        ).unwrap();
-        check_gl_errors!(cx);
-
-        let marker_tex = {
-            let img = image::load_from_memory(
-                include_bytes!("../img/marker.png"),
-            ).unwrap();
-            Texture::new(cx, &img).unwrap()
-        };
-
-        marker_program.add_texture(cx, &marker_tex, CStr::from_bytes_with_nul(b"tex\0").unwrap());
-
-        marker_program.add_attribute(
-            cx,
-            CStr::from_bytes_with_nul(b"position\0").unwrap(),
-            &VertexAttribParams::new(2, 4, 0)
-        );
-        marker_program.add_attribute(
-            cx,
-            CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(),
-            &VertexAttribParams::new(2, 4, 2)
-        );
-
         MapViewGl {
             map_view,
             viewport_size: initial_size,
@@ -143,10 +107,7 @@ impl MapViewGl {
             tile_buffer,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
             tile_atlas: TileAtlas::new(cx, atlas_tex, 256, use_async),
-            marker_buffer,
-            marker_program,
-            marker_tex,
-            markers: vec![],
+            marker_layer: MarkerLayer::new(cx),
             last_draw_type: DrawType::Null,
         }
     }
@@ -158,7 +119,7 @@ impl MapViewGl {
     }
 
     pub fn add_marker(&mut self, map_coord: MapCoord) {
-        self.markers.push(map_coord);
+        self.marker_layer.add_marker(map_coord);
     }
 
     pub fn viewport_in_map(&self) -> bool {
@@ -282,88 +243,10 @@ impl MapViewGl {
     fn draw_marker(&mut self, cx: &mut Context, snap_to_pixel: bool) {
         if self.last_draw_type != DrawType::Markers {
             self.last_draw_type = DrawType::Markers;
-            cx.set_active_texture_unit(self.marker_tex.unit());
-            self.marker_program.enable_vertex_attribs(cx);
-            self.marker_program.set_vertex_attribs(cx, &self.marker_buffer);
-        }
-
-        let mut vertex_data: Vec<f32> = vec![];
-
-        let marker_size = vec2::<f64>(40.0, 50.0);
-        let marker_offset = vec2::<f64>(-20.0, -50.0);
-
-        let scale_x = 2.0 / self.viewport_size.0 as f32;
-        let scale_y = -2.0 / self.viewport_size.1 as f32;
-
-        let tex_mat: Matrix3<f32> = Matrix3::from_cols(
-            vec3(marker_size.x as f32, 0.0, 0.0),
-            vec3(0.0, marker_size.y as f32, 0.0),
-            vec3(marker_offset.x as f32, marker_offset.y as f32, 1.0),
-        );
-
-        let screen_mat: Matrix3<f32> = Matrix3::from_cols(
-            vec3(scale_x, 0.0, 0.0),
-            vec3(0.0, scale_y, 0.0),
-            vec3(-1.0, 1.0, 1.0),
-        );
-
-        let t1 = Point2::new(0.0f32, 0.0);
-        let t2 = Point2::new(1.0f32, 0.0);
-        let t3 = Point2::new(1.0f32, 1.0);
-        let t4 = Point2::new(0.0f32, 1.0);
-
-        let visible_rect = ScreenRect {
-            x: -(marker_offset.x + marker_size.x),
-            y: -(marker_offset.y + marker_size.y),
-            width: f64::from(self.viewport_size.0) + marker_size.x,
-            height: f64::from(self.viewport_size.1) + marker_size.y,
-        };
-
-        for m in &self.markers {
-            let screen_pos = {
-                let mut sp = self.map_view.map_to_screen_coord(*m);
-                if snap_to_pixel {
-                    let topleft = self.map_view.map_to_screen_coord(MapCoord::new(0.0, 0.0));
-                    let mut snapped = topleft;
-                    snapped.snap_to_pixel();
-
-                    sp.x += snapped.x - topleft.x;
-                    sp.y += snapped.y - topleft.y;
-                }
-                sp
-            };
-
-            if !screen_pos.is_inside(&visible_rect) {
-                continue;
-            }
-            let trans_mat: Matrix3<f32> = Matrix3::from_cols(
-                vec3(0.0, 0.0, 0.0),
-                vec3(0.0, 0.0, 0.0),
-                vec3(screen_pos.x as f32, screen_pos.y as f32, 0.0),
-            );
-            let mat: Matrix3<f32> = screen_mat * (tex_mat + trans_mat);
-
-            let p1: Point2<f32> = mat.transform_point(t1);
-            let p2: Point2<f32> = mat.transform_point(t2);
-            let p3: Point2<f32> = mat.transform_point(t3);
-            let p4: Point2<f32> = mat.transform_point(t4);
-
-            vertex_data.extend::<&[f32; 2]>(p1.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t1.as_ref());
-            vertex_data.extend::<&[f32; 2]>(p2.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t2.as_ref());
-            vertex_data.extend::<&[f32; 2]>(p3.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t3.as_ref());
-            vertex_data.extend::<&[f32; 2]>(p1.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t1.as_ref());
-            vertex_data.extend::<&[f32; 2]>(p3.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t3.as_ref());
-            vertex_data.extend::<&[f32; 2]>(p4.as_ref());
-            vertex_data.extend::<&[f32; 2]>(t4.as_ref());
+            self.marker_layer.prepare_draw(cx);
         }
 
-        self.marker_buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
-        self.marker_buffer.draw(cx, &self.marker_program, DrawMode::Triangles);
+        self.marker_layer.draw(cx, &self.map_view, self.viewport_size, snap_to_pixel);
     }
 
     /// Returns `Err` when tile cache is too small for this view.
@@ -375,7 +258,7 @@ impl MapViewGl {
 
         let ret = self.draw_tiles(cx, source, snap_to_pixel);
 
-        if !self.markers.is_empty() {
+        if !self.marker_layer.is_empty() {
             self.draw_marker(cx, snap_to_pixel);
         }
 

src/marker_layer.rs

@@ -0,0 +1,162 @@
+use ::std::ffi::CStr;
+use buffer::{Buffer, DrawMode};
+use cgmath::{Matrix3, Point2, Transform, vec2, vec3};
+use context::Context;
+use coord::{MapCoord, ScreenRect};
+use image;
+use map_view::MapView;
+use program::Program;
+use texture::Texture;
+use vertex_attrib::VertexAttribParams;
+
+
+#[derive(Debug)]
+pub struct MarkerLayer {
+    buffer: Buffer,
+    program: Program,
+    texture: Texture,
+    positions: Vec<MapCoord>,
+}
+
+impl MarkerLayer {
+    pub fn new(cx: &mut Context) -> MarkerLayer {
+        let buffer = Buffer::new(cx, &[], 0);
+        cx.bind_buffer(buffer.id());
+        check_gl_errors!(cx);
+
+        let mut program = Program::new(
+            cx,
+            include_bytes!("../shader/marker.vert"),
+            include_bytes!("../shader/marker.frag"),
+        ).unwrap();
+        check_gl_errors!(cx);
+
+        let texture = {
+            let img = image::load_from_memory(
+                include_bytes!("../img/marker.png"),
+            ).unwrap();
+            Texture::new(cx, &img).unwrap()
+        };
+
+        program.add_texture(cx, &texture, CStr::from_bytes_with_nul(b"tex\0").unwrap());
+
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"position\0").unwrap(),
+            &VertexAttribParams::new(2, 4, 0)
+        );
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(),
+            &VertexAttribParams::new(2, 4, 2)
+        );
+
+        MarkerLayer {
+            buffer,
+            program,
+            texture,
+            positions: vec![],
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.positions.is_empty()
+    }
+
+    pub fn add_marker(&mut self, map_coord: MapCoord) {
+        self.positions.push(map_coord);
+    }
+
+    // Has to be called once before one or multiple calls to `draw`.
+    pub fn prepare_draw(&mut self, cx: &mut Context) {
+        cx.set_active_texture_unit(self.texture.unit());
+        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,
+        viewport_size: (u32, u32),
+        snap_to_pixel: bool
+    ) {
+        let mut vertex_data: Vec<f32> = vec![];
+
+        let marker_size = vec2::<f64>(40.0, 50.0);
+        let marker_offset = vec2::<f64>(-20.0, -50.0);
+
+        let scale_x = 2.0 / viewport_size.0 as f32;
+        let scale_y = -2.0 / viewport_size.1 as f32;
+
+        let tex_mat: Matrix3<f32> = Matrix3::from_cols(
+            vec3(marker_size.x as f32, 0.0, 0.0),
+            vec3(0.0, marker_size.y as f32, 0.0),
+            vec3(marker_offset.x as f32, marker_offset.y as f32, 1.0),
+        );
+
+        let screen_mat: Matrix3<f32> = Matrix3::from_cols(
+            vec3(scale_x, 0.0, 0.0),
+            vec3(0.0, scale_y, 0.0),
+            vec3(-1.0, 1.0, 1.0),
+        );
+
+        let t1 = Point2::new(0.0f32, 0.0);
+        let t2 = Point2::new(1.0f32, 0.0);
+        let t3 = Point2::new(1.0f32, 1.0);
+        let t4 = Point2::new(0.0f32, 1.0);
+
+        let visible_rect = ScreenRect {
+            x: -(marker_offset.x + marker_size.x),
+            y: -(marker_offset.y + marker_size.y),
+            width: f64::from(viewport_size.0) + marker_size.x,
+            height: f64::from(viewport_size.1) + marker_size.y,
+        };
+
+        for map_pos in &self.positions {
+            let screen_pos = {
+                let mut sp = map_view.map_to_screen_coord(*map_pos);
+                if snap_to_pixel {
+                    let topleft = map_view.map_to_screen_coord(MapCoord::new(0.0, 0.0));
+                    let mut snapped = topleft;
+                    snapped.snap_to_pixel();
+
+                    sp.x += snapped.x - topleft.x;
+                    sp.y += snapped.y - topleft.y;
+                }
+                sp
+            };
+
+            if !screen_pos.is_inside(&visible_rect) {
+                continue;
+            }
+            let trans_mat: Matrix3<f32> = Matrix3::from_cols(
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(screen_pos.x as f32, screen_pos.y as f32, 0.0),
+            );
+            let mat: Matrix3<f32> = screen_mat * (tex_mat + trans_mat);
+
+            let p1: Point2<f32> = mat.transform_point(t1);
+            let p2: Point2<f32> = mat.transform_point(t2);
+            let p3: Point2<f32> = mat.transform_point(t3);
+            let p4: Point2<f32> = mat.transform_point(t4);
+
+            vertex_data.extend::<&[f32; 2]>(p1.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t1.as_ref());
+            vertex_data.extend::<&[f32; 2]>(p2.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t2.as_ref());
+            vertex_data.extend::<&[f32; 2]>(p3.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t3.as_ref());
+            vertex_data.extend::<&[f32; 2]>(p1.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t1.as_ref());
+            vertex_data.extend::<&[f32; 2]>(p3.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t3.as_ref());
+            vertex_data.extend::<&[f32; 2]>(p4.as_ref());
+            vertex_data.extend::<&[f32; 2]>(t4.as_ref());
+        }
+
+        self.buffer.set_data(cx, &vertex_data, vertex_data.len() / 4);
+        self.buffer.draw(cx, &self.program, DrawMode::Triangles);
+    }
+}