[core] Change OverscaledTileID to also include a "wrap" value.

This prevents TilePyramid from sharing wrapped copies of tiles.
This is necessary because two wrapped tiles no longer share the same CollisionTile.

3 files changed, 23 insertions, 26 deletions

diff --git a/src/mbgl/algorithm/update_renderables.hpp b/src/mbgl/algorithm/update_renderables.hpp
index a9c348b538..0c2266ff47 100644
--- a/src/mbgl/algorithm/update_renderables.hpp
+++ b/src/mbgl/algorithm/update_renderables.hpp
@@ -31,7 +31,7 @@ void updateRenderables(GetTileFn getTile,
         assert(idealRenderTileID.canonical.z <= zoomRange.max);
         assert(dataTileZoom >= idealRenderTileID.canonical.z);
 
-        const OverscaledTileID idealDataTileID(dataTileZoom, idealRenderTileID.canonical);
+        const OverscaledTileID idealDataTileID(dataTileZoom, idealRenderTileID.wrap, idealRenderTileID.canonical);
         auto tile = getTile(idealDataTileID);
         if (!tile) {
             tile = createTile(idealDataTileID);
@@ -64,11 +64,11 @@ void updateRenderables(GetTileFn getTile,
             } else {
                 // Check all four actual child tiles.
                 for (const auto& childTileID : idealDataTileID.canonical.children()) {
-                    const OverscaledTileID childDataTileID(overscaledZ, childTileID);
+                    const OverscaledTileID childDataTileID(overscaledZ, idealRenderTileID.wrap, childTileID);
                     tile = getTile(childDataTileID);
                     if (tile && tile->isRenderable()) {
                         retainTile(*tile, Resource::Necessity::Optional);
-                        renderTile(childDataTileID.unwrapTo(idealRenderTileID.wrap), *tile);
+                        renderTile(childDataTileID.toUnwrapped(), *tile);
                     } else {
                         // At least one child tile doesn't exist, so we are going to look for
                         // parents as well.
@@ -81,8 +81,7 @@ void updateRenderables(GetTileFn getTile,
                 // We couldn't find child tiles that entirely cover the ideal tile.
                 for (overscaledZ = dataTileZoom - 1; overscaledZ >= zoomRange.min; --overscaledZ) {
                     const auto parentDataTileID = idealDataTileID.scaledTo(overscaledZ);
-                    const auto parentRenderTileID =
-                        parentDataTileID.unwrapTo(idealRenderTileID.wrap);
+                    const auto parentRenderTileID = parentDataTileID.toUnwrapped();
 
                     if (checked.find(parentRenderTileID) != checked.end()) {
                         // Break parent tile ascent, this route has been checked by another child
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index 57e7f6d375..5b1e621743 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -176,15 +176,12 @@ void TilePyramid::update(const std::vector<Immutable<style::Layer::Impl>>& layer
     removeStaleTiles(retain);
 
     for (auto& pair : tiles) {
-        // TODO: Calculating yStretch based on tile distance means we can no longer use the same collision tile for two wrapped
-        // copies of the same data tile. For now the assumption that we're always at "wrap = 0" means collision detection is broken
-        // for wrapped tiles.
         const PlacementConfig config { parameters.transformState.getAngle(),
                                        parameters.transformState.getPitch(),
                                        parameters.transformState.getCameraToCenterDistance(),
-                                       parameters.transformState.getCameraToTileDistance(pair.first.unwrapTo(0)),
+                                       parameters.transformState.getCameraToTileDistance(pair.first.toUnwrapped()),
                                        parameters.debugOptions & MapDebugOptions::Collision };
-        
+
         pair.second->setPlacementConfig(config);
     }
 }
diff --git a/src/mbgl/tile/tile_id.hpp b/src/mbgl/tile/tile_id.hpp
index 1ce3eea98e..811158e9b9 100644
--- a/src/mbgl/tile/tile_id.hpp
+++ b/src/mbgl/tile/tile_id.hpp
@@ -46,8 +46,8 @@ std::string toString(const CanonicalTileID&);
 // z/x/y describe the
 class OverscaledTileID {
 public:
-    OverscaledTileID(uint8_t overscaledZ, CanonicalTileID);
-    OverscaledTileID(uint8_t overscaledZ, uint8_t z, uint32_t x, uint32_t y);
+    OverscaledTileID(uint8_t overscaledZ, int16_t wrap, CanonicalTileID);
+    OverscaledTileID(uint8_t overscaledZ, int16_t wrap, uint8_t z, uint32_t x, uint32_t y);
     OverscaledTileID(uint8_t z, uint32_t x, uint32_t y);
     explicit OverscaledTileID(const CanonicalTileID&);
     explicit OverscaledTileID(CanonicalTileID&&);
@@ -57,9 +57,10 @@ public:
     bool isChildOf(const OverscaledTileID&) const;
     uint32_t overscaleFactor() const;
     OverscaledTileID scaledTo(uint8_t z) const;
-    UnwrappedTileID unwrapTo(int16_t wrap) const;
+    UnwrappedTileID toUnwrapped() const;
 
     const uint8_t overscaledZ;
+    const int16_t wrap;
     const CanonicalTileID canonical;
 };
 
@@ -137,40 +138,40 @@ inline std::array<CanonicalTileID, 4> CanonicalTileID::children() const {
     } };
 }
 
-inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, CanonicalTileID canonical_)
-    : overscaledZ(overscaledZ_), canonical(std::move(canonical_)) {
+inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, int16_t wrap_, CanonicalTileID canonical_)
+    : overscaledZ(overscaledZ_), wrap(wrap_), canonical(std::move(canonical_)) {
     assert(overscaledZ >= canonical.z);
 }
 
-inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, uint8_t z, uint32_t x, uint32_t y)
-    : overscaledZ(overscaledZ_), canonical(z, x, y) {
+inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, int16_t wrap_, uint8_t z, uint32_t x, uint32_t y)
+    : overscaledZ(overscaledZ_), wrap(wrap_), canonical(z, x, y) {
     assert(overscaledZ >= canonical.z);
 }
 
 inline OverscaledTileID::OverscaledTileID(uint8_t z, uint32_t x, uint32_t y)
-    : overscaledZ(z), canonical(z, x, y) {
+    : overscaledZ(z), wrap(0), canonical(z, x, y) {
 }
 
 inline OverscaledTileID::OverscaledTileID(const CanonicalTileID& canonical_)
-    : overscaledZ(canonical_.z), canonical(canonical_) {
+    : overscaledZ(canonical_.z), wrap(0), canonical(canonical_) {
     assert(overscaledZ >= canonical.z);
 }
 
 inline OverscaledTileID::OverscaledTileID(CanonicalTileID&& canonical_)
-    : overscaledZ(canonical_.z), canonical(std::forward<CanonicalTileID>(canonical_)) {
+    : overscaledZ(canonical_.z), wrap(0), canonical(std::forward<CanonicalTileID>(canonical_)) {
     assert(overscaledZ >= canonical.z);
 }
 
 inline bool OverscaledTileID::operator==(const OverscaledTileID& rhs) const {
-    return overscaledZ == rhs.overscaledZ && canonical == rhs.canonical;
+    return overscaledZ == rhs.overscaledZ && wrap == rhs.wrap &&canonical == rhs.canonical;
 }
 
 inline bool OverscaledTileID::operator!=(const OverscaledTileID& rhs) const {
-    return overscaledZ != rhs.overscaledZ || canonical != rhs.canonical;
+    return overscaledZ != rhs.overscaledZ || wrap != rhs.wrap || canonical != rhs.canonical;
 }
 
 inline bool OverscaledTileID::operator<(const OverscaledTileID& rhs) const {
-    return std::tie(overscaledZ, canonical) < std::tie(rhs.overscaledZ, rhs.canonical);
+    return std::tie(overscaledZ, wrap, canonical) < std::tie(rhs.overscaledZ, rhs.wrap, rhs.canonical);
 }
 
 inline uint32_t OverscaledTileID::overscaleFactor() const {
@@ -183,10 +184,10 @@ inline bool OverscaledTileID::isChildOf(const OverscaledTileID& rhs) const {
 }
 
 inline OverscaledTileID OverscaledTileID::scaledTo(uint8_t z) const {
-    return { z, z >= canonical.z ? canonical : canonical.scaledTo(z) };
+    return { z, wrap, z >= canonical.z ? canonical : canonical.scaledTo(z) };
 }
 
-inline UnwrappedTileID OverscaledTileID::unwrapTo(int16_t wrap) const {
+inline UnwrappedTileID OverscaledTileID::toUnwrapped() const {
     return { wrap, canonical };
 }
 
@@ -232,7 +233,7 @@ inline std::array<UnwrappedTileID, 4> UnwrappedTileID::children() const {
 
 inline OverscaledTileID UnwrappedTileID::overscaleTo(const uint8_t overscaledZ) const {
     assert(overscaledZ >= canonical.z);
-    return { overscaledZ, canonical };
+    return { overscaledZ, wrap, canonical };
 }
 
 inline float UnwrappedTileID::pixelsToTileUnits(const float pixelValue, const float zoom) const {