Show tiles from a higher zoom level to fill gaps

src/coord.rs

     pub height: f64,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TileCoord {
-    pub zoom: u32,
-    pub x: i32,
-    pub y: i32,
+impl ScreenRect {
+    pub fn subdivide(&self, sub_tile: &SubTileCoord) -> ScreenRect {
+        let scale = 1.0 / f64::from(sub_tile.size);
+        let w = self.width * scale;
+        let h = self.height * scale;
+        ScreenRect {
+            x: self.x + f64::from(sub_tile.x) * w,
+            y: self.y + f64::from(sub_tile.y) * h,
+            width: w,
+            height: h,
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
     pub y: u32,
 }
 
+impl SubTileCoord {
+    pub fn subdivide(&self, other: &SubTileCoord) -> SubTileCoord {
+        SubTileCoord {
+            x: self.x * other.size + other.x,
+            y: self.y * other.size + other.y,
+            size: self.size * other.size,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TileCoord {
+    pub zoom: u32,
+    pub x: i32,
+    pub y: i32,
+}
+
 impl TileCoord {
     pub fn new(zoom: u32, x: i32, y: i32) -> TileCoord {
         TileCoord {
         }
     }
 
+    pub fn children(&self) -> [(TileCoord, SubTileCoord); 4] {
+        [
+            (
+                TileCoord {
+                    zoom: self.zoom + 1,
+                    x: self.x * 2,
+                    y: self.y * 2,
+                },
+                SubTileCoord {
+                    size: 2,
+                    x: 0,
+                    y: 0,
+                },
+            ),
+            (
+                TileCoord {
+                    zoom: self.zoom + 1,
+                    x: self.x * 2 + 1,
+                    y: self.y * 2,
+                },
+                SubTileCoord {
+                    size: 2,
+                    x: 1,
+                    y: 0,
+                },
+            ),
+            (
+                TileCoord {
+                    zoom: self.zoom + 1,
+                    x: self.x * 2,
+                    y: self.y * 2 + 1,
+                },
+                SubTileCoord {
+                    size: 2,
+                    x: 0,
+                    y: 1,
+                },
+            ),
+            (
+                TileCoord {
+                    zoom: self.zoom + 1,
+                    x: self.x * 2 + 1,
+                    y: self.y * 2 + 1,
+                },
+                SubTileCoord {
+                    size: 2,
+                    x: 1,
+                    y: 1,
+                },
+            ),
+        ]
+    }
+
     #[inline]
     fn normalize_coord(coord: i32, zoom: u32) -> i32 {
         let max = Self::get_zoom_level_tiles(zoom);

src/tile_cache_gl.rs

             y2: self.y2 - margin_y,
         }
     }
+
+    pub fn subdivide(&self, sub_tile: &SubTileCoord) -> TextureRect {
+        let scale = 1.0 / f64::from(sub_tile.size);
+        let w = (self.x2 - self.x1) * scale;
+        let h = (self.y2 - self.y1) * scale;
+        TextureRect {
+            x1: self.x1 + f64::from(sub_tile.x) * w,
+            y1: self.y1 + f64::from(sub_tile.y) * h,
+            x2: self.x1 + f64::from(sub_tile.x + 1) * w,
+            y2: self.y1 + f64::from(sub_tile.y + 1) * h,
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
                     }
                 );
             } else {
-                // look for cached tiles in lower zoom layers
+                // exact tile not found
+
+                // default tile
                 let mut tex_sub_rect = self.slot_to_texture_rect(Self::default_slot());
                 let mut tex_rect = tex_sub_rect;
+
+                // 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) {
                             tex_rect = self.slot_to_texture_rect(slot);
                             break;
                         }
+                    } else {
+                        break;
                     }
                 }
-                tvt.push(
-                    TexturedVisibleTile {
-                        screen_rect: vt.rect,
-                        tex_rect: tex_sub_rect,
-                        tex_minmax: tex_rect.inset(inset_x, inset_y),
+
+                // 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) {
+                        let tex_rect = self.slot_to_texture_rect(slot);
+
+                        tvt.push(
+                            TexturedVisibleTile {
+                                screen_rect: vt.rect.subdivide(&child_sub_coord),
+                                tex_rect: tex_rect,
+                                tex_minmax: tex_rect.inset(inset_x, inset_y),
+                            }
+                        );
+                    } else {
+                        tvt.push(
+                            TexturedVisibleTile {
+                                screen_rect: vt.rect.subdivide(&child_sub_coord),
+                                tex_rect: tex_sub_rect.subdivide(&child_sub_coord),
+                                tex_minmax: tex_rect.inset(inset_x, inset_y),
+                            }
+                        );
                     }
-                );
+                }
             };
-
         }
 
         tvt