Refactor tileCover to support lod tiles

5 files changed, 434 insertions, 148 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2ed92eb987..35d8f2300f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -81,6 +81,7 @@ add_library(
     ${PROJECT_SOURCE_DIR}/test/tile/tile_id.test.cpp
     ${PROJECT_SOURCE_DIR}/test/tile/vector_tile.test.cpp
     ${PROJECT_SOURCE_DIR}/test/util/async_task.test.cpp
+    ${PROJECT_SOURCE_DIR}/test/util/bounding_volumes.test.cpp
     ${PROJECT_SOURCE_DIR}/test/util/dtoa.test.cpp
     ${PROJECT_SOURCE_DIR}/test/util/geo.test.cpp
     ${PROJECT_SOURCE_DIR}/test/util/grid_index.test.cpp
diff --git a/test/algorithm/update_renderables.test.cpp b/test/algorithm/update_renderables.test.cpp
index 6958f21ea2..bca04ab661 100644
--- a/test/algorithm/update_renderables.test.cpp
+++ b/test/algorithm/update_renderables.test.cpp
@@ -122,14 +122,14 @@ TEST(UpdateRenderables, SingleTile) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 1, 1 });
+    source.idealTiles.emplace(OverscaledTileID{1, 1, 1});
 
     // Make sure that we're getting the tile back.
     auto tile_1_1_1_1 = source.createTileData(OverscaledTileID{ 1, 1, 1 });
     tile_1_1_1_1->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 1, 1 } }, Found },       // found ideal tile
                   RetainTileDataAction{ { 1, 0, { 1, 1, 1 } }, TileNecessity::Required }, //
@@ -139,8 +139,8 @@ TEST(UpdateRenderables, SingleTile) {
 
     // Check a repeated render with the same data.
     log.clear();
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 1, 1 } }, Found },       // found ideal tile
                   RetainTileDataAction{ { 1, 0, { 1, 1, 1 } }, TileNecessity::Required }, //
@@ -150,9 +150,9 @@ TEST(UpdateRenderables, SingleTile) {
 
     // Insert a tile we don't have data for.
     log.clear();
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 1 });
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 1});
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, NotFound },    // missing ideal tile
                   CreateTileDataAction{ { 1, 0, { 1, 0, 1 } } },           // create ideal tile
@@ -172,8 +172,8 @@ TEST(UpdateRenderables, SingleTile) {
     // Mark the created tile as having the optional request tried.
     log.clear();
     source.dataTiles[{ 1, 0, { 1, 0, 1 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, Found },       // missing ideal tile
                   RetainTileDataAction{ { 1, 0, { 1, 0, 1 } }, TileNecessity::Required }, //
@@ -195,8 +195,8 @@ TEST(UpdateRenderables, SingleTile) {
     log.clear();
     auto tile_1_1_0_1 = source.createTileData(OverscaledTileID{ 1, 0, 1 });
     tile_1_1_0_1->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, Found },       // newly added tile
                   RetainTileDataAction{ { 1, 0, { 1, 0, 1 } }, TileNecessity::Required }, //
@@ -211,11 +211,11 @@ TEST(UpdateRenderables, SingleTile) {
     // Insert another tile, and another bucket that has a different name and check that we're not
     // using it.
     log.clear();
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 0});
     auto tile_1_1_0_0 = source.createTileData(OverscaledTileID{ 1, 0, 0 });
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found },       // found tile, not ready
                   RetainTileDataAction{ { 1, 0, { 1, 0, 0 } }, TileNecessity::Required }, //
@@ -240,8 +240,8 @@ TEST(UpdateRenderables, SingleTile) {
     // Then, add the bucket and check that it's getting used.
     log.clear();
     tile_1_1_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found },       // found tile, now ready
                   RetainTileDataAction{ { 1, 0, { 1, 0, 0 } }, TileNecessity::Required }, //
@@ -266,15 +266,15 @@ TEST(UpdateRenderables, UseParentTile) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 1 });
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 1, 0 });
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 1, 1 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 1});
+    source.idealTiles.emplace(OverscaledTileID{1, 1, 0});
+    source.idealTiles.emplace(OverscaledTileID{1, 1, 1});
 
     // Make sure that we're getting the tile back.
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, 0 });
     tile_0_0_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, NotFound },    // missing ideal tile
                   CreateTileDataAction{ { 1, 0, { 1, 0, 1 } } },           //
@@ -312,12 +312,12 @@ TEST(UpdateRenderables, DontUseWrongParentTile) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{2, 0, 0});
 
     auto tile_1_1_1_0 = source.createTileData(OverscaledTileID{ 1, 1, 0 });
     tile_1_1_1_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, NotFound },    // missing ideal tile
                   CreateTileDataAction{ { 2, 0, { 2, 0, 0 } } },           //
@@ -334,8 +334,8 @@ TEST(UpdateRenderables, DontUseWrongParentTile) {
     // Now mark the created tile as having the optional request tried.
     log.clear();
     source.dataTiles[{ 2, 0, { 2, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, Found },       // non-ready ideal tile
                   RetainTileDataAction{ { 2, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -352,9 +352,9 @@ TEST(UpdateRenderables, DontUseWrongParentTile) {
 
     // Add a new child tile and check that it is now used.
     log.clear();
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 2, 0 });
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    source.idealTiles.emplace(OverscaledTileID{2, 2, 0});
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, Found },       // non-ready ideal tile
                   RetainTileDataAction{ { 2, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -389,7 +389,7 @@ TEST(UpdateRenderables, UseParentTileWhenChildNotReady) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 1 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 1});
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, 0 });
     tile_0_0_0_0->renderable = true;
@@ -398,8 +398,8 @@ TEST(UpdateRenderables, UseParentTileWhenChildNotReady) {
     // Don't create bucket.
 
     // Make sure that it renders the parent tile.
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, Found },       // found, but not ready
                   RetainTileDataAction{ { 1, 0, { 1, 0, 1 } }, TileNecessity::Required }, //
@@ -416,8 +416,8 @@ TEST(UpdateRenderables, UseParentTileWhenChildNotReady) {
     // Now insert the bucket and make sure we're now using the matching tile
     log.clear();
     tile_1_1_0_1->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 1 } }, Found },       // found and ready
                   RetainTileDataAction{ { 1, 0, { 1, 0, 1 } }, TileNecessity::Required }, //
@@ -434,8 +434,8 @@ TEST(UpdateRenderables, UseOverlappingParentTile) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 0 });
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 1 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 0});
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 1});
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, 0 });
     tile_0_0_0_0->renderable = true;
@@ -443,8 +443,8 @@ TEST(UpdateRenderables, UseOverlappingParentTile) {
     auto tile_1_1_0_1 = source.createTileData(OverscaledTileID{ 1, 0, 1 });
     tile_1_1_0_1->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, NotFound },    // ideal tile not found
                   CreateTileDataAction{ { 1, 0, { 1, 0, 0 } } },           //
@@ -472,15 +472,15 @@ TEST(UpdateRenderables, UseChildTiles) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 0, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{0, 0, 0});
 
     auto tile_1_1_0_0 = source.createTileData(OverscaledTileID{ 1, 0, 0 });
     tile_1_1_0_0->renderable = true;
     auto tile_1_1_1_0 = source.createTileData(OverscaledTileID{ 1, 1, 0 });
     tile_1_1_1_0->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 0);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 0, 0, { 0, 0, 0 } }, NotFound },    // ideal tile, missing
                   CreateTileDataAction{ { 0, 0, { 0, 0, 0 } } },           //
@@ -506,15 +506,15 @@ TEST(UpdateRenderables, PreferChildTiles) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 0});
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, 0 });
     tile_0_0_0_0->renderable = true;
     auto tile_2_2_0_0 = source.createTileData(OverscaledTileID{ 2, 0, 0 });
     tile_2_2_0_0->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, NotFound },    // ideal tile, not found
                   CreateTileDataAction{ { 1, 0, { 1, 0, 0 } } },           //
@@ -536,8 +536,8 @@ TEST(UpdateRenderables, PreferChildTiles) {
     log.clear();
     auto tile_2_2_0_1 = source.createTileData(OverscaledTileID{ 2, 0, 1 });
     tile_2_2_0_1->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found }, // ideal tile, not ready
                   // ideal tile was added in previous invocation, but is not yet ready
@@ -559,8 +559,8 @@ TEST(UpdateRenderables, PreferChildTiles) {
     log.clear();
     auto tile_2_2_1_0 = source.createTileData(OverscaledTileID{ 2, 1, 0 });
     tile_2_2_1_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found }, // ideal tile, not ready
                   // ideal tile was added in first invocation, but is not yet ready
@@ -585,8 +585,8 @@ TEST(UpdateRenderables, PreferChildTiles) {
     log.clear();
     auto tile_2_2_1_1 = source.createTileData(OverscaledTileID{ 2, 1, 1 });
     tile_2_2_1_1->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found }, // ideal tile, not ready
                   // ideal tile was added in first invocation, but is not yet ready
@@ -615,7 +615,7 @@ TEST(UpdateRenderables, UseParentAndChildTiles) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{1, 0, 0});
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, 0 });
     tile_0_0_0_0->renderable = true;
@@ -623,8 +623,8 @@ TEST(UpdateRenderables, UseParentAndChildTiles) {
     tile_2_2_0_0->renderable = true;
 
     // Check that it uses the child tile and the parent tile to cover the rest.
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, NotFound },    // ideal tile, missing
                   CreateTileDataAction{ { 1, 0, { 1, 0, 0 } } },           //
@@ -644,8 +644,8 @@ TEST(UpdateRenderables, UseParentAndChildTiles) {
     // Then, remove the child tile and check that it now only the parent tile.
     log.clear();
     source.dataTiles.erase(OverscaledTileID{ 2, 0, 0 });
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, 0, { 1, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 1, 0, { 1, 0, 0 } }, TileNecessity::Required }, //
@@ -669,13 +669,13 @@ TEST(UpdateRenderables, DontUseTilesLowerThanMinzoom) {
     auto renderTile = renderTileFn(log);
 
     source.zoomRange.min = 2;
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{2, 0, 0});
 
     auto tile_1_1_0_0 = source.createTileData(OverscaledTileID{ 1, 0, 0 });
     tile_1_1_0_0->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, NotFound },    // ideal tile, missing
                   CreateTileDataAction{ { 2, 0, { 2, 0, 0 } } },           //
@@ -698,13 +698,13 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
     auto renderTile = renderTileFn(log);
 
     source.zoomRange.max = 2;
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{2, 0, 0});
 
     // Add a child tile (that should never occur in practice) and make sure it's not selected.
     auto tile_3_3_0_0 = source.createTileData(OverscaledTileID{ 3, 0, 0 });
     tile_3_3_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(
         ActionLog({
             GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, NotFound },    // ideal tile, missing
@@ -719,8 +719,8 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
     // Mark the created tile as having tried the optional request.
     log.clear();
     source.dataTiles[{ 2, 0, { 2, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(
         ActionLog({
             GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, Found },       // ideal tile, missing
@@ -733,12 +733,14 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
         }),
         log);
 
-    // Only add a non-overzoomed ("parent") tile at first.
+    // Switch to overzoomed tile and only add a non-overzoomed ("parent") tile at first.
     log.clear();
+    source.idealTiles.clear();
+    source.idealTiles.emplace(OverscaledTileID{3, 0, {2, 0, 0}});
     auto tile_2_2_0_0 = source.createTileData(OverscaledTileID{ 2, 0, { 2, 0, 0 } });
     tile_2_2_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, NotFound },    // ideal tile, missing
                   CreateTileDataAction{ { 3, 0, { 2, 0, 0 } } },           //
@@ -754,8 +756,8 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
     log.clear();
     auto tile_3_2_0_0 = source.createTileData(OverscaledTileID{ 3, 0, { 2, 0, 0 } });
     tile_3_2_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, Found },       //
                   RetainTileDataAction{ { 3, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -765,8 +767,10 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
 
     // Check that it's switching back to the tile that has the matching overzoom value.
     log.clear();
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    source.idealTiles.clear();
+    source.idealTiles.emplace(OverscaledTileID{2, 0, 0});
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, Found },       //
                   RetainTileDataAction{ { 2, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -780,8 +784,8 @@ TEST(UpdateRenderables, UseOverzoomedTileAfterMaxzoom) {
     tile_2_2_0_0 = nullptr;
 
     // Use the overzoomed tile even though it doesn't match the zoom level.
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, NotFound },    //
                   CreateTileDataAction{ { 2, 0, { 2, 0, 0 } } },           //
@@ -802,13 +806,13 @@ TEST(UpdateRenderables, AscendToNonOverzoomedTiles) {
     auto renderTile = renderTileFn(log);
 
     source.zoomRange.max = 2;
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{3, 0, {2, 0, 0}});
 
     // Add a matching overzoomed tile and make sure it gets selected.
     auto tile_3_2_0_0 = source.createTileData(OverscaledTileID{ 3, 0, { 2, 0, 0 } });
     tile_3_2_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, Found },       //
                   RetainTileDataAction{ { 3, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -822,8 +826,8 @@ TEST(UpdateRenderables, AscendToNonOverzoomedTiles) {
     tile_3_2_0_0 = nullptr;
     auto tile_2_2_0_0 = source.createTileData(OverscaledTileID{ 2, 0, { 2, 0, 0 } });
     tile_2_2_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, NotFound },    //
                   CreateTileDataAction{ { 3, 0, { 2, 0, 0 } } },           //
@@ -841,8 +845,8 @@ TEST(UpdateRenderables, AscendToNonOverzoomedTiles) {
     tile_2_2_0_0 = nullptr;
     auto tile_1_1_0_0 = source.createTileData(OverscaledTileID{ 1, 0, { 1, 0, 0 } });
     tile_1_1_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 3, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -857,8 +861,8 @@ TEST(UpdateRenderables, AscendToNonOverzoomedTiles) {
     // Now, mark the created tile as found.
     log.clear();
     source.dataTiles[{ 3, 0, { 2, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 3);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 3, 0, { 2, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 3, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -881,11 +885,11 @@ TEST(UpdateRenderables, DoNotAscendMultipleTimesIfNotFound) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 8, 0, 0 });
-    source.idealTiles.emplace(UnwrappedTileID{ 8, 1, 0 });
+    source.idealTiles.emplace(OverscaledTileID{8, 0, 0});
+    source.idealTiles.emplace(OverscaledTileID{8, 1, 0});
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 8);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 8, 0, { 8, 0, 0 } }, NotFound },    // ideal tile
                   CreateTileDataAction{ { 8, 0, { 8, 0, 0 } } },           //
@@ -919,8 +923,8 @@ TEST(UpdateRenderables, DoNotAscendMultipleTimesIfNotFound) {
     auto tile_4_0_0_0 = source.createTileData(OverscaledTileID{ 4, 0, { 4, 0, 0 } });
     tile_4_0_0_0->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 8);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 8, 0, { 8, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 8, 0, { 8, 0, 0 } }, TileNecessity::Required }, //
@@ -954,13 +958,13 @@ TEST(UpdateRenderables, DontRetainUnusedNonIdealTiles) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{2, 0, 0});
 
     source.createTileData(OverscaledTileID{ 1, 0, 0 });
     source.createTileData(OverscaledTileID{ 2, 0, 0 });
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 2);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 2, 0, { 2, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 2, 0, { 2, 0, 0 } }, TileNecessity::Required }, //
@@ -983,16 +987,22 @@ TEST(UpdateRenderables, WrappedTiles) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 1, -1, 0 }); // 'wrap' -> -1
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 0, 0 });  // 'wrap' -> 0
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 1, 0 });  // 'wrap' -> 0
-    source.idealTiles.emplace(UnwrappedTileID{ 1, 2, 0 });  // 'wrap' -> 1
+    UnwrappedTileID tileIds[] = {
+        {1, -1, 0}, // 'wrap' -> -1
+        {1, 0, 0},  // 'wrap' -> 0
+        {1, 1, 0},  // 'wrap' -> 0
+        {1, 2, 0}   // 'wrap' -> 1
+    };
+
+    for (const auto& id : tileIds) {
+        source.idealTiles.emplace(OverscaledTileID{1, id.wrap, id.canonical});
+    }
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{ 0, 0, { 0, 0, 0 } });
     tile_0_0_0_0->renderable = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 1);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 1, -1, { 1, 1, 0 } }, NotFound },    // ideal tile 1/-1/0 (wrapped to -1)
                   CreateTileDataAction{ { 1, -1, { 1, 1, 0 } } },           //
@@ -1043,10 +1053,10 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{ 6, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{6, 0, 0});
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, NotFound },    // ideal tile, not found
                   CreateTileDataAction{ { 6, 0, { 6, 0, 0 } } },           //
@@ -1066,8 +1076,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
 
     // Repeat.
     log.clear();
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1087,8 +1097,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     // Mark next level has having tried optional.
     log.clear();
     source.dataTiles[{ 6, 0, { 6, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1109,8 +1119,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
 
     // Repeat.
     log.clear();
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1131,8 +1141,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     // Mark next level has having tried optional.
     log.clear();
     source.dataTiles[{ 5, 0, { 5, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1155,8 +1165,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     // Mark next level has having tried optional.
     log.clear();
     source.dataTiles[{ 4, 0, { 4, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1180,8 +1190,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     // Mark next level has having tried optional.
     log.clear();
     source.dataTiles[{ 3, 0, { 3, 0, 0 } }]->triedOptional = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1207,8 +1217,8 @@ TEST(UpdateRenderables, RepeatedRenderWithMissingOptionals) {
     log.clear();
     auto tile_3_3_0_0 = source.dataTiles[{ 3, 0, { 3, 0, 0 } }].get();
     tile_3_3_0_0->renderable = true;
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found },       // ideal tile, not ready
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1236,14 +1246,14 @@ TEST(UpdateRenderables, LoadRequiredIfIdealTileCantBeFound) {
     auto renderTile = renderTileFn(log);
 
     source.zoomRange.max = 6;
-    source.idealTiles.emplace(UnwrappedTileID{ 6, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{6, 0, 0});
 
     auto tile_6_6_0_0 = source.createTileData(OverscaledTileID{ 6, 0, { 6, 0, 0 } });
     tile_6_6_0_0->triedOptional = true;
     tile_6_6_0_0->loaded = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 6);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 6, 0, { 6, 0, 0 } }, Found }, // ideal tile, not found
                   RetainTileDataAction{ { 6, 0, { 6, 0, 0 } }, TileNecessity::Required }, //
@@ -1270,7 +1280,7 @@ TEST(UpdateRenderables, LoadOverscaledMaxZoomTile) {
     auto renderTile = renderTileFn(log);
 
     source.zoomRange.max = 2;
-    source.idealTiles.emplace(UnwrappedTileID{ 2, 0, 0 });
+    source.idealTiles.emplace(OverscaledTileID{4, 0, {2, 0, 0}});
 
     auto tile_4_2_0_0 = source.createTileData(OverscaledTileID{ 4, 0, { 2, 0, 0 } });
     tile_4_2_0_0->renderable = false;
@@ -1293,8 +1303,8 @@ TEST(UpdateRenderables, LoadOverscaledMaxZoomTile) {
     tile_1_1_0_0->triedOptional = true;
     tile_1_1_0_0->loaded = true;
 
-    algorithm::updateRenderables(getTileData, createTileData, retainTileData, renderTile,
-                                 source.idealTiles, source.zoomRange, 4);
+    algorithm::updateRenderables(
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange);
     EXPECT_EQ(ActionLog({
                   GetTileDataAction{ { 4, 0, { 2, 0, 0 } }, Found },
                   RetainTileDataAction{ { 4, 0, { 2, 0, 0 } }, TileNecessity::Required },
@@ -1318,15 +1328,15 @@ TEST(UpdateRenderables, MaxParentOverscaleFactor) {
     auto retainTileData = retainTileDataFn(log);
     auto renderTile = renderTileFn(log);
 
-    source.idealTiles.emplace(UnwrappedTileID{4, 0, 0});
-    source.idealTiles.emplace(UnwrappedTileID{4, 1, 0});
+    source.idealTiles.emplace(OverscaledTileID{4, 0, 0});
+    source.idealTiles.emplace(OverscaledTileID{4, 1, 0});
 
     auto tile_0_0_0_0 = source.createTileData(OverscaledTileID{0, 0, 0});
     tile_0_0_0_0->renderable = true;
 
     // Set max parent overscale factor to 4, so that tile 0,0,0 would be rendered
     algorithm::updateRenderables(
-        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange, 4, 4);
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange, 4);
     EXPECT_EQ(ActionLog({GetTileDataAction{{4, 0, {4, 0, 0}}, NotFound}, // ideal tile
                          CreateTileDataAction{{4, 0, {4, 0, 0}}},
                          RetainTileDataAction{{4, 0, {4, 0, 0}}, TileNecessity::Required},
@@ -1354,7 +1364,7 @@ TEST(UpdateRenderables, MaxParentOverscaleFactor) {
     // Set max parent overscale factor to 3.
     // Parent tile 0,0,0 should not be requested / rendered.
     algorithm::updateRenderables(
-        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange, 4, 3);
+        getTileData, createTileData, retainTileData, renderTile, source.idealTiles, source.zoomRange, 3);
     EXPECT_EQ(ActionLog({GetTileDataAction{{4, 0, {4, 0, 0}}, Found}, // ideal tile
                          RetainTileDataAction{{4, 0, {4, 0, 0}}, TileNecessity::Required},
                          GetTileDataAction{{5, 0, {5, 0, 0}}, NotFound}, // child tiles
diff --git a/test/src/mbgl/test/mock.hpp b/test/src/mbgl/test/mock.hpp
index b8eb020105..c61cdf56f4 100644
--- a/test/src/mbgl/test/mock.hpp
+++ b/test/src/mbgl/test/mock.hpp
@@ -14,7 +14,7 @@ struct MockTileData;
 struct MockSource {
     mbgl::Range<uint8_t> zoomRange { 0, 16 };
     std::map<mbgl::OverscaledTileID, std::unique_ptr<MockTileData>> dataTiles;
-    std::set<mbgl::UnwrappedTileID> idealTiles;
+    std::set<mbgl::OverscaledTileID> idealTiles;
 
     // Test API
     inline MockTileData* createTileData(const mbgl::OverscaledTileID& tileID);
diff --git a/test/util/bounding_volumes.test.cpp b/test/util/bounding_volumes.test.cpp
new file mode 100644
index 0000000000..c788c9919a
--- /dev/null
+++ b/test/util/bounding_volumes.test.cpp
@@ -0,0 +1,152 @@
+#include <mbgl/util/bounding_volumes.hpp>
+
+#include <gtest/gtest.h>
+#include <math.h>
+
+using namespace mbgl;
+
+TEST(BoundingVolumes, CreateAabb) {
+    util::AABB aabb({0, 0, 0}, {2, 4, 6});
+
+    EXPECT_EQ(aabb.min, (vec3{0, 0, 0}));
+    EXPECT_EQ(aabb.max, (vec3{2, 4, 6}));
+}
+
+TEST(BoundingVolumes, AabbEquality) {
+    util::AABB aabb0({-4.23, 1.01, 2.0}, {-1.0, 1.02, 100.0});
+    util::AABB aabb1({-4.23, 1.01, 2.0}, {-1.0, 1.02, 100.0});
+    util::AABB aabb2({-4.23, 1.01, 2.0}, {-1.0, 1.03, 55.0});
+
+    EXPECT_EQ(aabb0, aabb1);
+    EXPECT_NE(aabb0, aabb2);
+}
+
+TEST(BoundingVolumes, CreateAabbQuadrants) {
+    util::AABB aabb({0, 0, 0}, {2, 4, 16});
+
+    util::AABB quadrant0({0, 0, 0}, {1, 2, 16});
+    util::AABB quadrant1({1, 0, 0}, {2, 2, 16});
+    util::AABB quadrant2({0, 2, 0}, {1, 4, 16});
+    util::AABB quadrant3({1, 2, 0}, {2, 4, 16});
+
+    EXPECT_EQ(aabb.quadrant(0), quadrant0);
+    EXPECT_EQ(aabb.quadrant(1), quadrant1);
+    EXPECT_EQ(aabb.quadrant(2), quadrant2);
+    EXPECT_EQ(aabb.quadrant(3), quadrant3);
+}
+
+TEST(BoundingVolumes, AabbDistanceToPoint) {
+    util::AABB aabb({-1.0, -1.0, -1.0}, {1.0, 1.0, 1.0});
+
+    EXPECT_EQ(aabb.distanceXYZ({0.5, -0.5, 0.5}), (vec3{0, 0, 0}));
+    EXPECT_EQ(aabb.distanceXYZ({1, 1, 1}), (vec3{0, 0, 0}));
+    EXPECT_EQ(aabb.distanceXYZ({0, 10, 0}), (vec3{0, 9, 0}));
+    EXPECT_EQ(aabb.distanceXYZ({-2, -2, -4}), (vec3{1, 1, 3}));
+}
+
+TEST(BoundingVolumes, AabbAabbIntersection) {
+    util::AABB aabb0({1, 0, 0}, {3, 2, 1});
+    util::AABB aabb1({2.5, 1.5, -1}, {6.0, 2.5, 1});
+    util::AABB aabb2({3.5, -2, -2}, {5.0, 1, -1.5});
+    util::AABB aabb3({0.5, -1, -1}, {6.5, 3, 4});
+
+    EXPECT_EQ(aabb0.intersects(aabb1), true);
+    EXPECT_EQ(aabb0.intersects(aabb2), false);
+    EXPECT_EQ(aabb1.intersects(aabb2), false);
+    EXPECT_EQ(aabb3.intersects(aabb0), true);
+    EXPECT_EQ(aabb3.intersects(aabb1), true);
+    EXPECT_EQ(aabb3.intersects(aabb2), false);
+}
+
+TEST(BoundingVolumes, CreateFrustumFromProjectionMatrix) {
+    mat4 projMatrix;
+    mat4 invProjMatrix;
+    matrix::perspective(projMatrix, M_PI_2, 1.0, 0.1, 100.0);
+    matrix::invert(invProjMatrix, projMatrix);
+
+    const util::Frustum frustum = util::Frustum::fromInvProjMatrix(invProjMatrix, 1.0, 0.0, false);
+
+    const std::array<vec3, 8> expectedPoints = {vec3{-0.1, 0.1, -0.1},
+                                                vec3{0.1, 0.1, -0.1},
+                                                vec3{0.1, -0.1, -0.1},
+                                                vec3{-0.1, -0.1, -0.1},
+                                                vec3{-100.0, 100.0, -100.0},
+                                                vec3{100.0, 100.0, -100.0},
+                                                vec3{100.0, -100.0, -100.0},
+                                                vec3{-100.0, -100.0, -100.0}};
+
+    const std::array<vec4, 6> expectedPlanes = {
+
+        vec4{0, -0.707, 0.707, 0},
+        vec4{-0.707, 0, 0.707, 0},
+        vec4{0.707, 0, 0.707, 0},
+        vec4{0, 0.707, 0.707, 0},
+        vec4{0, 0, 1.0, 0.1},
+        vec4{0, 0, -1.0, -100.0}};
+
+    const auto roundPoint = [](vec3& v) {
+        for (auto& p : v) {
+            p = round(p * 10.0) / 10.0;
+        }
+    };
+
+    const auto roundPlane = [](vec4& v) {
+        for (auto& p : v) {
+            p = round(p * 1000.0) / 1000.0;
+        }
+    };
+
+    std::array<vec3, 8> actualPoints = frustum.getPoints();
+    std::array<vec4, 6> actualPlanes = frustum.getPlanes();
+
+    std::for_each(actualPoints.begin(), actualPoints.end(), roundPoint);
+    std::for_each(actualPlanes.begin(), actualPlanes.end(), roundPlane);
+
+    EXPECT_EQ(actualPoints, expectedPoints);
+    EXPECT_EQ(actualPlanes, expectedPlanes);
+}
+
+static util::Frustum createTestFrustum(
+    double fovy, double aspectRatio, double zNear, double zFar, double elevation, double bearing) {
+    mat4 proj;
+    mat4 invProj;
+
+    // Create a complete projection matrix for transforming from world space to clip space
+    matrix::perspective(proj, fovy, aspectRatio, zNear, zFar);
+    matrix::scale(proj, proj, 1, -1, 1);
+    matrix::translate(proj, proj, 0, 0, elevation);
+    matrix::rotate_z(proj, proj, bearing);
+    matrix::invert(invProj, proj);
+
+    return util::Frustum::fromInvProjMatrix(invProj, 1.0, 0.0);
+}
+
+TEST(BoundingVolumes, AabbFullyInsideFrustum) {
+    const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, 0.0);
+
+    const std::array<util::AABB, 3> aabbArray = {
+        util::AABB({-1, -1, 0}, {1, 1, 0}), util::AABB({-5, -5, 0}, {5, 5, 0}), util::AABB({-5, -5, 0}, {-4, -2, 0})};
+
+    EXPECT_EQ(frustum.intersects(aabbArray[0]), util::IntersectionResult::Contains);
+    EXPECT_EQ(frustum.intersects(aabbArray[1]), util::IntersectionResult::Contains);
+    EXPECT_EQ(frustum.intersects(aabbArray[2]), util::IntersectionResult::Contains);
+}
+
+TEST(BoundingVolumes, AabbIntersectsFrustum) {
+    const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, 0.0);
+
+    const std::array<util::AABB, 2> aabbArray = {util::AABB({-6, -6, 0}, {6, 6, 0}),
+                                                 util::AABB({-6, -6, 0}, {-5, -5, 0})};
+
+    EXPECT_EQ(frustum.intersects(aabbArray[0]), util::IntersectionResult::Intersects);
+    EXPECT_EQ(frustum.intersects(aabbArray[1]), util::IntersectionResult::Intersects);
+}
+
+TEST(BoundingVolumes, AabbIntersectsFrustumEdgeCase) {
+    const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, M_PI_4);
+    const util::AABB aabb({-10, 10, 0}, {10, 12, 0});
+
+    // Intersection test should report intersection even though shapes are separate
+    EXPECT_EQ(frustum.intersects(aabb), util::IntersectionResult::Intersects);
+    EXPECT_EQ(frustum.intersectsPrecise(aabb), util::IntersectionResult::Separate);
+}
\ No newline at end of file
diff --git a/test/util/tile_cover.test.cpp b/test/util/tile_cover.test.cpp
index ba39bfa61b..2401608d45 100644
--- a/test/util/tile_cover.test.cpp
+++ b/test/util/tile_cover.test.cpp
@@ -37,9 +37,7 @@ TEST(TileCover, Pitch) {
 
     transform.jumpTo(CameraOptions().withCenter(LatLng { 0.1, -0.1, }).withZoom(2.0).withBearing(5.0).withPitch(40.0));
 
-    EXPECT_EQ((std::vector<UnwrappedTileID>{
-        { 2, 1, 1 }, { 2, 2, 1 }, { 2, 1, 2 }, { 2, 2, 2 }
-    }),
+    EXPECT_EQ((std::vector<OverscaledTileID>{{2, 1, 1}, {2, 2, 1}, {2, 1, 2}, {2, 2, 2}}),
               util::tileCover(transform.getState(), 2));
 }
 
@@ -51,25 +49,23 @@ TEST(TileCover, PitchIssue15442) {
         .withZoom(2.0551126748417214).withBearing(0.74963938256567264 * util::RAD2DEG)
         .withPitch(1.0471975511965976 * util::RAD2DEG));
 
-    EXPECT_EQ((std::vector<UnwrappedTileID>{
-        { 2, 3, 1 }, { 2, 2, 1 }, { 2, 3, 0 }, { 2, 2, 0 }, { 1, { 2, 0, 0 } }, { 1, { 2, 1, 0 } }
-    }),
+    EXPECT_EQ((std::vector<OverscaledTileID>{
+                  {2, 3, 1}, {2, 2, 1}, {2, 3, 0}, {2, 2, 0}, {2, 1, {2, 0, 0}}, {2, 1, {2, 1, 0}}}),
               util::tileCover(transform.getState(), 2));
 }
 
 TEST(TileCover, PitchOverAllowedByContentInsets) {
     Transform transform;
-    transform.resize({ 512, 512 });
+    transform.resize({512, 512});
 
     transform.jumpTo(CameraOptions().withCenter(LatLng { 0.1, -0.1 }).withPadding(EdgeInsets { 376, 0, 0, 0 })
                                     .withZoom(8.0).withBearing(45.0).withPitch(60.0));
     // Top padding of 376 leads to capped pitch. See Transform::getMaxPitchForEdgeInsets.
     EXPECT_LE(transform.getPitch() + 0.001, util::DEG2RAD * 60);
 
-    EXPECT_EQ((std::vector<UnwrappedTileID>{
-        { 3, 4, 3 }, { 3, 3, 3 }, { 3, 4, 4 }, { 3, 3, 4 }, { 3, 4, 2 }, { 3, 5, 3 }, { 3, 5, 2 }
-    }),
-              util::tileCover(transform.getState(), 3));
+    EXPECT_EQ(
+        (std::vector<OverscaledTileID>{{3, 4, 3}, {3, 3, 3}, {3, 4, 4}, {3, 3, 4}, {3, 4, 2}, {3, 5, 3}, {3, 5, 2}}),
+        util::tileCover(transform.getState(), 3));
 }
 
 TEST(TileCover, PitchWithLargerResultSet) {
@@ -84,29 +80,156 @@ TEST(TileCover, PitchWithLargerResultSet) {
     auto cover = util::tileCover(transform.getState(), 5);
     // Returned vector has above 100 elements, we check first 16 as there is a
     // plan to return lower LOD for distant tiles.
-    EXPECT_EQ((std::vector<UnwrappedTileID> {
-        { 5, 15, 16 }, { 5, 15, 17 }, { 5, 14, 16 }, { 5, 14, 17 },
-        { 5, 16, 16 }, { 5, 16, 17 }, { 5, 15, 15 }, { 5, 14, 15 },
-        { 5, 15, 18 }, { 5, 14, 18 }, { 5, 16, 15 }, { 5, 13, 16 },
-        { 5, 13, 17 }, { 5, 16, 18 }, { 5, 13, 18 }, { 5, 15, 19 }
-    }), (std::vector<UnwrappedTileID> { cover.begin(), cover.begin() + 16}) );
+    EXPECT_EQ((std::vector<OverscaledTileID>{{5, 15, 16},
+                                             {5, 15, 17},
+                                             {5, 14, 16},
+                                             {5, 14, 17},
+                                             {5, 16, 16},
+                                             {5, 16, 17},
+                                             {5, 15, 15},
+                                             {5, 14, 15},
+                                             {5, 15, 18},
+                                             {5, 14, 18},
+                                             {5, 16, 15},
+                                             {5, 13, 16},
+                                             {5, 13, 17},
+                                             {5, 16, 18},
+                                             {5, 13, 18},
+                                             {5, 15, 19}}),
+              (std::vector<OverscaledTileID>{cover.begin(), cover.begin() + 16}));
 }
 
 TEST(TileCover, WorldZ1) {
     EXPECT_EQ((std::vector<UnwrappedTileID>{
-        { 1, 0, 0 }, { 1, 0, 1 }, { 1, 1, 0 }, { 1, 1, 1 },
-    }),
+                  {1, 0, 0},
+                  {1, 0, 1},
+                  {1, 1, 0},
+                  {1, 1, 1},
+              }),
               util::tileCover(LatLngBounds::world(), 1));
 }
 
 TEST(TileCover, SingletonZ0) {
-    EXPECT_EQ((std::vector<UnwrappedTileID>{}),
-              util::tileCover(LatLngBounds::singleton({ 0, 0 }), 0));
+    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::singleton({0, 0}), 0));
 }
 
 TEST(TileCover, SingletonZ1) {
-    EXPECT_EQ((std::vector<UnwrappedTileID>{}),
-              util::tileCover(LatLngBounds::singleton({ 0, 0 }), 1));
+    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::singleton({0, 0}), 1));
+}
+
+TEST(TileCover, CoordinatesAreUnwrapped) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             0.1,
+                             -180.1,
+                         })
+                         .withZoom(1.0));
+
+    EXPECT_EQ(
+        (std::vector<OverscaledTileID>{{1, 0, {1, 1, 0}}, {1, 1, {1, 0, 0}}, {1, 0, {1, 1, 1}}, {1, 1, {1, 0, 1}}}),
+        util::tileCover(transform.getState(), 1));
+}
+
+TEST(TileCover, DifferentOverscaledZ) {
+    Transform transform;
+    transform.resize({512, 512});
+    // slightly offset center so that tile order is better defined
+
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             0.1,
+                             -0.1,
+                         })
+                         .withZoom(2.0));
+
+    EXPECT_EQ(
+        (std::vector<OverscaledTileID>{{3, 0, {2, 1, 1}}, {3, 0, {2, 2, 1}}, {3, 0, {2, 1, 2}}, {3, 0, {2, 2, 2}}}),
+        util::tileCover(transform.getState(), 2, 3));
+}
+
+TEST(TileCover, DifferentOverscaledZWithPitch) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             30.0,
+                             -10.0,
+                         })
+                         .withZoom(3.5)
+                         .withPitch(60));
+
+    EXPECT_EQ((std::vector<OverscaledTileID>{{5, 0, {3, 3, 3}},
+                                             {5, 0, {3, 4, 3}},
+                                             {5, 0, {3, 3, 2}},
+                                             {5, 0, {3, 4, 2}},
+                                             {5, 0, {3, 3, 1}},
+                                             {5, 0, {3, 4, 1}},
+                                             {5, 0, {3, 2, 1}}}),
+              util::tileCover(transform.getState(), 3, 5));
+}
+
+TEST(TileCover, DifferentOverscaledZWrapped) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             0.1,
+                             -180.1,
+                         })
+                         .withZoom(1.0));
+
+    EXPECT_EQ(
+        (std::vector<OverscaledTileID>{{2, 0, {1, 1, 0}}, {2, 1, {1, 0, 0}}, {2, 0, {1, 1, 1}}, {2, 1, {1, 0, 1}}}),
+        util::tileCover(transform.getState(), 1, 2));
+}
+
+TEST(TileCover, FlippedY) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.setViewportMode(ViewportMode::FlippedY);
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             0.2,
+                             -0.1,
+                         })
+                         .withZoom(1.0));
+
+    EXPECT_EQ((std::vector<OverscaledTileID>{{1, 0, 0}, {1, 1, 0}, {1, 0, 1}, {1, 1, 1}}),
+              util::tileCover(transform.getState(), 1));
+}
+
+TEST(TileCover, FlippedYPitch) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.setViewportMode(ViewportMode::FlippedY);
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             0.1,
+                             -0.1,
+                         })
+                         .withZoom(2.0)
+                         .withBearing(5.0)
+                         .withPitch(40.0));
+
+    EXPECT_EQ((std::vector<OverscaledTileID>{{2, 1, 1}, {2, 2, 1}, {2, 1, 2}, {2, 2, 2}}),
+              util::tileCover(transform.getState(), 2));
+}
+
+TEST(TileCover, FlippedYHelsinki) {
+    Transform transform;
+    transform.resize({512, 512});
+    transform.setViewportMode(ViewportMode::FlippedY);
+    transform.jumpTo(CameraOptions()
+                         .withCenter(LatLng{
+                             60.167231,
+                             24.942063,
+                         })
+                         .withZoom(11.447425));
+
+    EXPECT_EQ((std::vector<OverscaledTileID>{{11, 1165, 592}, {11, 1166, 592}, {11, 1165, 593}, {11, 1166, 593}}),
+              util::tileCover(transform.getState(), 11));
 }
 
 TEST(TileCoverStream, Arctic) {