Fix seams between globe tiles

shader/globe_tile.frag

 precision mediump float;
 
 varying vec2 v_tex;
+varying vec4 v_tex_minmax;
 uniform sampler2D tex_map;
 
 void main() {
-    gl_FragColor = vec4(texture2D(tex_map, v_tex.xy).rgb, 1.0);
+    gl_FragColor = vec4(texture2D(tex_map, clamp(v_tex.xy, v_tex_minmax.xy, v_tex_minmax.zw)).rgb, 1.0);
 }

shader/globe_tile.vert

 
 attribute vec3 position;
 attribute vec2 tex_coord;
+attribute vec4 tex_minmax;
 
 varying vec2 v_tex;
+varying vec4 v_tex_minmax;
 
 void main() {
     gl_Position = vec4(position.xy, 0.0, 1.0);
     v_tex = tex_coord;
+    v_tex_minmax = tex_minmax;
 }

src/globe_tile_layer.rs

         program.add_attribute(
             cx,
             CStr::from_bytes_with_nul(b"position\0").unwrap(),
-            &VertexAttribParams::new(3, 5, 0)
+            &VertexAttribParams::new(3, 9, 0)
         );
         program.add_attribute(
             cx,
             CStr::from_bytes_with_nul(b"tex_coord\0").unwrap(),
-            &VertexAttribParams::new(2, 5, 3)
+            &VertexAttribParams::new(2, 9, 3)
+        );
+        program.add_attribute(
+            cx,
+            CStr::from_bytes_with_nul(b"tex_minmax\0").unwrap(),
+            &VertexAttribParams::new(4, 9, 5)
         );
         check_gl_errors!(cx);
 
 
         let rot_mat = Transform::<Point3<f32>>::concat(&rot_mat_y, &rot_mat_x);
 
+        let (inset_x, inset_y) = tile_atlas.texture_margins();
+
         for tile_y in 0..16 {
             for tile_x in 0..16 {
                 let tc = TileCoord::new(4, tile_x, tile_y);
                 let slot = tile_atlas.store(cx, tc, source, cache, true)
                     .unwrap_or_else(TileAtlas::default_slot);
                 let texrect = tile_atlas.slot_to_texture_rect(slot);
+                let tex_minmax = texrect.inset(inset_x, inset_y);
+
+                let minmax = [
+                    tex_minmax.x1 as f32,
+                    tex_minmax.y1 as f32,
+                    tex_minmax.x2 as f32,
+                    tex_minmax.y2 as f32,
+                ];
 
                 for &(tc, sub_tile_a) in &tc.children() {
                     for &(tc, sub_tile_b) in &tc.children() {
                         let p4 = [p4.x as f32, p4.y as f32, p4.z as f32, texrect.x1 as f32, texrect.y2 as f32];
 
                         vertex_data.extend(&p1);
+                        vertex_data.extend(&minmax);
                         vertex_data.extend(&p2);
+                        vertex_data.extend(&minmax);
                         vertex_data.extend(&p3);
+                        vertex_data.extend(&minmax);
                         vertex_data.extend(&p1);
+                        vertex_data.extend(&minmax);
                         vertex_data.extend(&p3);
+                        vertex_data.extend(&minmax);
                         vertex_data.extend(&p4);
+                        vertex_data.extend(&minmax);
                     }
                 }
             }

src/tile_atlas.rs

         slot
     }
 
+    /// Return 0.5 pixels in texture coordinates for both dimensions.
+    pub fn texture_margins(&self) -> (f64, f64) {
+        (0.5 / f64::from(self.texture.width()),
+         0.5 / f64::from(self.texture.height()))
+    }
+
     /// Finds textures from the cache for a given slice of visible tiles. The texture atlas may not
     /// be big enough to hold all textures at once; a possible remainder of untextured visible tiles is
     /// returned as an `Option`.
     {
         let mut tvt = Vec::with_capacity(visible_tiles.len());
 
-        let inset_x = 0.5 / f64::from(self.texture.width());
-        let inset_y = 0.5 / f64::from(self.texture.height());
+        let (inset_x, inset_y) = self.texture_margins();
 
         let num_usable_slots = self.slots_lru.len();
         // The number of actually used slots may be lower, because slots can be used multiple times