Add TileCoord::children_iter method and Iterator

src/coord.rs

@@ -343,6 +343,18 @@ impl TileCoord {
         }
     }
 
+    pub fn children_iter(&self, zoom_delta: u32) -> TileChildrenIter {
+        let zoom_level_tiles = Self::get_zoom_level_tiles(zoom_delta);
+        TileChildrenIter {
+            zoom: self.zoom + zoom_delta,
+            tile_base_x: self.x * zoom_level_tiles,
+            tile_base_y: self.y * zoom_level_tiles,
+            child_x: -1,
+            child_y: 0,
+            zoom_level_tiles,
+        }
+    }
+
     pub fn children(&self) -> [(TileCoord, SubTileCoord); 4] {
         [
             (
@@ -432,6 +444,44 @@ impl TileCoord {
     }
 }
 
+pub struct TileChildrenIter {
+    zoom: u32,
+    tile_base_x: i32,
+    tile_base_y: i32,
+    child_x: i32,
+    child_y: i32,
+    zoom_level_tiles: i32,
+}
+
+impl Iterator for TileChildrenIter {
+    type Item = (TileCoord, SubTileCoord);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.child_x += 1;
+
+        if self.child_x >= self.zoom_level_tiles {
+            self.child_x = 0;
+            self.child_y += 1;
+        }
+        if self.child_y >= self.zoom_level_tiles {
+            return None;
+        }
+
+        Some((
+            TileCoord {
+                zoom: self.zoom,
+                x: self.tile_base_x + self.child_x,
+                y: self.tile_base_y + self.child_y,
+            },
+            SubTileCoord {
+                size: self.zoom_level_tiles as u32,
+                x: self.child_x as u32,
+                y: self.child_y as u32,
+            },
+        ))
+    }
+}
+
 //TODO include width and height of view rect to determine visibility
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct View {
@@ -531,4 +581,15 @@ mod tests {
         assert!(approx_eq(deg.lat, -0.5 * PI));
         assert!(approx_eq(deg.lon, PI));
     }
+
+    #[test]
+    fn tile_children() {
+        let t = TileCoord::new(2, 1, 2);
+        for (&(a1, a2), (b1, b2)) in t.children().iter().zip(t.children_iter(1)) {
+            assert_eq!(a1, b1);
+            assert_eq!(a2, b2);
+        }
+        assert_eq!(t.children_iter(1).collect::<Vec<_>>().len(), 4);
+        assert_eq!(t.children_iter(2).collect::<Vec<_>>().len(), 16);
+    }
 }

src/globe_tile_layer.rs

@@ -123,9 +123,9 @@ impl GlobeTileLayer {
 
         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);
+        for tile_y in 0..8 {
+            for tile_x in 0..8 {
+                let tc = TileCoord::new(3, 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);
@@ -138,53 +138,49 @@ impl GlobeTileLayer {
                     tex_minmax.y2 as f32,
                 ];
 
-                for &(tc, sub_tile_a) in &tc.children() {
-                    for &(tc, sub_tile_b) in &tc.children() {
-                        let sub_tile = sub_tile_a.subdivide(&sub_tile_b);
-
-                        let ll_nw = tc.latlon_rad_north_west();
-                        let ll_se = {
-                            let tc = TileCoord::new(tc.zoom, tc.x + 1, tc.y + 1);
-                            tc.latlon_rad_north_west()
-                        };
-
-                        let ll_ne = LatLonRad::new(ll_nw.lat, ll_se.lon);
-                        let ll_sw = LatLonRad::new(ll_se.lat, ll_nw.lon);
-
-                        let p1 = ll_nw.to_sphere_point3(1.0);
-                        let p2 = ll_ne.to_sphere_point3(1.0);
-                        let p3 = ll_se.to_sphere_point3(1.0);
-                        let p4 = ll_sw.to_sphere_point3(1.0);
-
-                        let p1 = transform.transform_point(p1);
-                        let p2 = transform.transform_point(p2);
-                        let p3 = transform.transform_point(p3);
-                        let p4 = transform.transform_point(p4);
-
-                        if p1.z > 0.0 && p2.z > 0.0 && p3.z > 0.0 && p4.z > 0.0 {
-                            continue;
-                        }
-
-                        let texrect = texrect.subdivide(&sub_tile);
-
-                        let p1 = [p1.x as f32, p1.y as f32, p1.z as f32, texrect.x1 as f32, texrect.y1 as f32];
-                        let p2 = [p2.x as f32, p2.y as f32, p2.z as f32, texrect.x2 as f32, texrect.y1 as f32];
-                        let p3 = [p3.x as f32, p3.y as f32, p3.z as f32, texrect.x2 as f32, texrect.y2 as f32];
-                        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);
+                for (tc, sub_tile) in tc.children_iter(3) {
+                    let ll_nw = tc.latlon_rad_north_west();
+                    let ll_se = {
+                        let tc = TileCoord::new(tc.zoom, tc.x + 1, tc.y + 1);
+                        tc.latlon_rad_north_west()
+                    };
+
+                    let ll_ne = LatLonRad::new(ll_nw.lat, ll_se.lon);
+                    let ll_sw = LatLonRad::new(ll_se.lat, ll_nw.lon);
+
+                    let p1 = ll_nw.to_sphere_point3(1.0);
+                    let p2 = ll_ne.to_sphere_point3(1.0);
+                    let p3 = ll_se.to_sphere_point3(1.0);
+                    let p4 = ll_sw.to_sphere_point3(1.0);
+
+                    let p1 = transform.transform_point(p1);
+                    let p2 = transform.transform_point(p2);
+                    let p3 = transform.transform_point(p3);
+                    let p4 = transform.transform_point(p4);
+
+                    if p1.z > 0.0 && p2.z > 0.0 && p3.z > 0.0 && p4.z > 0.0 {
+                        continue;
                     }
+
+                    let texrect = texrect.subdivide(&sub_tile);
+
+                    let p1 = [p1.x as f32, p1.y as f32, p1.z as f32, texrect.x1 as f32, texrect.y1 as f32];
+                    let p2 = [p2.x as f32, p2.y as f32, p2.z as f32, texrect.x2 as f32, texrect.y1 as f32];
+                    let p3 = [p3.x as f32, p3.y as f32, p3.z as f32, texrect.x2 as f32, texrect.y2 as f32];
+                    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);
                 }
             }
         }