[core] retain tiles differently and remove old TileID class

3 files changed, 118 insertions, 0 deletions

diff --git a/src/mbgl/algorithm/update_renderables.cpp b/src/mbgl/algorithm/update_renderables.cpp
new file mode 100644
index 0000000000..7b571308c7
--- /dev/null
+++ b/src/mbgl/algorithm/update_renderables.cpp
@@ -0,0 +1,10 @@
+#include <mbgl/algorithm/update_renderables_impl.hpp>
+#include <mbgl/style/style_layer.hpp>
+
+namespace mbgl {
+namespace algorithm {
+
+//template void updateRenderables(StyleLayer& layer, const uint8_t z);
+
+} // namespace algorithm
+} // namespace mbgl
diff --git a/src/mbgl/algorithm/update_renderables.hpp b/src/mbgl/algorithm/update_renderables.hpp
new file mode 100644
index 0000000000..a1fa6b1e6c
--- /dev/null
+++ b/src/mbgl/algorithm/update_renderables.hpp
@@ -0,0 +1,15 @@
+#ifndef MBGL_ALGORITHM_UPDATE_RENDERABLES
+#define MBGL_ALGORITHM_UPDATE_RENDERABLES
+
+#include <cstdint>
+
+namespace mbgl {
+namespace algorithm {
+
+template <typename Layer>
+void updateRenderables(Layer& layer, const uint8_t z);
+
+} // namespace algorithm
+} // namespace mbgl
+
+#endif
diff --git a/src/mbgl/algorithm/update_renderables_impl.hpp b/src/mbgl/algorithm/update_renderables_impl.hpp
new file mode 100644
index 0000000000..d7221be21c
--- /dev/null
+++ b/src/mbgl/algorithm/update_renderables_impl.hpp
@@ -0,0 +1,93 @@
+#ifndef MBGL_ALGORITHM_UPDATE_RENDERABLES_IMPL
+#define MBGL_ALGORITHM_UPDATE_RENDERABLES_IMPL
+
+#include <mbgl/algorithm/update_renderables.hpp>
+#include <mbgl/tile/tile_id.hpp>
+
+#include <map>
+
+namespace mbgl {
+namespace algorithm {
+
+namespace {
+
+template <typename DataTiles, typename Renderables>
+bool tryTile(const UnwrappedTileID& renderTileID,
+             const OverscaledTileID& dataTileID,
+             const DataTiles& dataTiles,
+             Renderables& renderables) {
+    if (renderables.find(renderTileID) == renderables.end()) {
+        const auto it = dataTiles.find(dataTileID);
+        if (it == dataTiles.end() || !it->second->isReady()) {
+            return false;
+        }
+
+        using Renderable = typename Renderables::mapped_type;
+        renderables.emplace(renderTileID, Renderable{ renderTileID, *it->second });
+    }
+
+    return true;
+}
+
+} // namespace
+
+template <typename Renderable, typename DataTiles, typename IdealTileIDs, typename SourceInfo>
+std::map<UnwrappedTileID, Renderable> updateRenderables(const DataTiles& dataTiles,
+                                                        const IdealTileIDs& idealTileIDs,
+                                                        const SourceInfo& info,
+                                                        const uint8_t z) {
+    std::map<UnwrappedTileID, Renderable> renderables;
+
+    // for (all in the set of ideal tiles of the source) {
+    for (const auto& renderTileID : idealTileIDs) {
+        assert(renderTileID.canonical.z >= info.minZoom);
+        assert(renderTileID.canonical.z <= info.maxZoom);
+        assert(z >= renderTileID.canonical.z);
+        const auto wrap = renderTileID.wrap;
+        const OverscaledTileID dataTileID(z, renderTileID.canonical);
+
+        // if (source has the tile and bucket is loaded) {
+        if (!tryTile(renderTileID, dataTileID, dataTiles, renderables)) {
+            // The source doesn't have the tile, or the bucket isn't loaded.
+            bool covered = true;
+            int32_t overscaledZ = z + 1;
+            if (overscaledZ > info.maxZoom) {
+                // We're looking for an overzoomed child tile.
+                const auto childDataTileID = dataTileID.scaledTo(overscaledZ);
+                if (!tryTile(renderTileID, childDataTileID, dataTiles, renderables)) {
+                    covered = false;
+                }
+            } else {
+                // Check all four actual child tiles.
+                for (const auto& childTileID : dataTileID.canonical.children()) {
+                    const OverscaledTileID childDataTileID(overscaledZ, childTileID);
+                    const UnwrappedTileID childRenderTileID(wrap, childTileID);
+                    if (!tryTile(childRenderTileID, childDataTileID, dataTiles, renderables)) {
+                        // At least one child tile doesn't exist, so we are going to look for
+                        // parents as well.
+                        covered = false;
+                    }
+                }
+            }
+
+            if (!covered) {
+                // We couldn't find child tiles that entirely cover the ideal tile.
+                for (overscaledZ = z - 1; overscaledZ >= info.minZoom; --overscaledZ) {
+                    const auto parentDataTileID = dataTileID.scaledTo(overscaledZ);
+                    const auto parentRenderTileID = parentDataTileID.unwrapTo(renderTileID.wrap);
+                    if (tryTile(parentRenderTileID, parentDataTileID, dataTiles, renderables)) {
+                        // Break parent tile ascent, since we found one.
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    return renderables;
+}
+
+} // namespace algorithm
+} // namespace mbgl
+
+#endif