Map overscaledTiles

4 files changed, 61 insertions, 27 deletions

diff --git a/include/mbgl/style/sources/custom_vector_source.hpp b/include/mbgl/style/sources/custom_vector_source.hpp
index 78835f2bed..c65a9992d8 100644
--- a/include/mbgl/style/sources/custom_vector_source.hpp
+++ b/include/mbgl/style/sources/custom_vector_source.hpp
@@ -4,26 +4,30 @@
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/geojson.hpp>
-#include <mbgl/util/variant.hpp>
 #include <mbgl/actor/actor_ref.hpp>
-#include <mbgl/util/noncopyable.hpp>
 
 namespace mbgl {
+
+class OverscaledTileID;
+
 namespace style {
 
 struct Error { std::string message; };
 
-using SetTileDataFunction = std::function<void(const CanonicalTileID& tileID, const mapbox::geojson::geojson&)>;
+using SetTileDataFunction = std::function<void(const mapbox::geojson::geojson&)>;
 using TileFunction = std::function<void(const CanonicalTileID&)>;
 
 class CustomTileLoader : private util::noncopyable {
 public:
     CustomTileLoader(TileFunction&& fetchTileFn, TileFunction&& cancelTileFn);
     ~CustomTileLoader();
-    void fetchTile(const CanonicalTileID& tileID, ActorRef<SetTileDataFunction> callbackRef);
-    void cancelTile(const CanonicalTileID& tileID);
+
+    void fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef);
+    void cancelTile(const OverscaledTileID& tileID);
+    void removeTile(const OverscaledTileID& tileID);
+
     void setTileData(const CanonicalTileID& tileID, const mapbox::geojson::geojson& data);
-    void removeTile(const CanonicalTileID& tileID);
+
 private:
     class Impl;
     Impl* impl = nullptr;
diff --git a/src/mbgl/style/sources/custom_vector_source.cpp b/src/mbgl/style/sources/custom_vector_source.cpp
index 38e708a7a8..c1b3f390a9 100644
--- a/src/mbgl/style/sources/custom_vector_source.cpp
+++ b/src/mbgl/style/sources/custom_vector_source.cpp
@@ -2,43 +2,73 @@
 #include <mbgl/style/sources/custom_vector_source_impl.hpp>
 #include <mbgl/actor/scheduler.hpp>
 
+#include <tuple>
+
 namespace mbgl {
 namespace style {
 
 class CustomTileLoader::Impl {
 public:
+
+    using OverscaledIDFunctionTuple = std::tuple<uint8_t, int16_t, ActorRef<SetTileDataFunction>>;
+
     Impl(TileFunction&& fetchTileFn, TileFunction&& cancelTileFn) {
         fetchTileFunction = std::move(fetchTileFn);
         cancelTileFunction = std::move(cancelTileFn);
     }
 
-    void fetchTile(const CanonicalTileID& tileID, ActorRef<SetTileDataFunction> callbackRef) {
-        fetchTileFunction(tileID);
-        auto insertResult = tileCallbackMap.insert({tileID, callbackRef});
-        if (insertResult.second == false) {
-            insertResult.first->second = callbackRef;
+    void fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef) {
+        fetchTileFunction(tileID.canonical);
+        auto tileCallbacks = tileCallbackMap.find(tileID.canonical);
+        if (tileCallbacks == tileCallbackMap.end()) {
+            auto tuple = std::make_tuple(tileID.overscaledZ, tileID.wrap, callbackRef);
+            tileCallbackMap.insert({ tileID.canonical, std::vector<OverscaledIDFunctionTuple>(1, tuple) });
+        }
+        else {
+            for(auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
+                if(std::get<0>(*iter) == tileID.overscaledZ && std::get<1>(*iter) == tileID.wrap ) {
+                    std::get<2>(*iter) = callbackRef;
+                    return;
+                }
+            }
+            tileCallbacks->second.emplace_back(std::make_tuple(tileID.overscaledZ, tileID.wrap, callbackRef));
         }
     }
 
-    void cancelTile(const CanonicalTileID& tileID) {
-        if(tileCallbackMap.find(tileID) != tileCallbackMap.end())
-            cancelTileFunction(tileID);
+    void cancelTile(const OverscaledTileID& tileID) {
+        if(tileCallbackMap.find(tileID.canonical) != tileCallbackMap.end()) {
+            cancelTileFunction(tileID.canonical);
+        }
     }
 
-    void removeTile(const CanonicalTileID& tileID) {
-        tileCallbackMap.erase(tileID);
+    void removeTile(const OverscaledTileID& tileID) {
+        auto tileCallbacks = tileCallbackMap.find(tileID.canonical);
+        if (tileCallbacks == tileCallbackMap.end()) return;
+        for(auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
+            if(std::get<0>(*iter) == tileID.overscaledZ && std::get<1>(*iter) == tileID.wrap ) {
+                tileCallbacks->second.erase(iter);
+                break;
+            }
+        }
+        if (tileCallbacks->second.size() == 0) {
+            tileCallbackMap.erase(tileCallbacks);
+        }
+        
     }
 
     void setTileData(const CanonicalTileID& tileID, const mapbox::geojson::geojson& data) {
         auto iter = tileCallbackMap.find(tileID);
         if (iter == tileCallbackMap.end()) return;
-        iter->second.invoke(&SetTileDataFunction::operator(), tileID, data);
+        for(auto tuple : iter->second) {
+            auto actor = std::get<2>(tuple);
+            actor.invoke(&SetTileDataFunction::operator(), data);
+        }
     }
 
 private:
     TileFunction fetchTileFunction;
     TileFunction cancelTileFunction;
-    std::unordered_map<CanonicalTileID, ActorRef<SetTileDataFunction>> tileCallbackMap;
+    std::unordered_map<CanonicalTileID, std::vector<OverscaledIDFunctionTuple>> tileCallbackMap;
 };
 
 
@@ -52,11 +82,11 @@ CustomTileLoader::~CustomTileLoader() {
     impl = nullptr;
 }
 
-void CustomTileLoader::fetchTile(const CanonicalTileID& tileID, ActorRef<SetTileDataFunction> callbackRef) {
+void CustomTileLoader::fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef) {
     impl->fetchTile(tileID, callbackRef);
 }
 
-void CustomTileLoader::cancelTile(const CanonicalTileID& tileID) {
+void CustomTileLoader::cancelTile(const OverscaledTileID& tileID) {
     impl->cancelTile(tileID);
 }
 
@@ -64,7 +94,7 @@ void CustomTileLoader::setTileData(const CanonicalTileID& tileID, const mapbox::
     impl->setTileData(tileID, data);
 }
 
-void CustomTileLoader::removeTile(const CanonicalTileID& tileID) {
+void CustomTileLoader::removeTile(const OverscaledTileID& tileID) {
     impl->removeTile(tileID);
 }
 
diff --git a/src/mbgl/tile/custom_tile.cpp b/src/mbgl/tile/custom_tile.cpp
index db9efaab95..926f608f87 100644
--- a/src/mbgl/tile/custom_tile.cpp
+++ b/src/mbgl/tile/custom_tile.cpp
@@ -21,14 +21,14 @@ CustomTile::CustomTile(const OverscaledTileID& overscaledTileID,
     necessity(Resource::Optional),
     options(options_),
     loader(loader_),
-    actor(*Scheduler::GetCurrent(), std::bind(&CustomTile::setTileData, this, std::placeholders::_1, std::placeholders::_2)) {
+    actor(*Scheduler::GetCurrent(), std::bind(&CustomTile::setTileData, this, std::placeholders::_1)) {
 }
 
 CustomTile::~CustomTile() {
-    loader.invoke(&style::CustomTileLoader::removeTile, id.canonical);
+    loader.invoke(&style::CustomTileLoader::removeTile, id);
 }
 
-void CustomTile::setTileData(const CanonicalTileID&, const mapbox::geojson::geojson& geoJSON) {
+void CustomTile::setTileData(const mapbox::geojson::geojson& geoJSON) {
     
     auto featureData = mapbox::geometry::feature_collection<int16_t>();
     if (geoJSON.is<FeatureCollection>() && !geoJSON.get<FeatureCollection>().empty()) {
@@ -49,9 +49,9 @@ void CustomTile::setNecessity(Necessity newNecessity) {
    if (newNecessity != necessity) {
         necessity = newNecessity;
         if (necessity == Necessity::Required) {
-            loader.invoke(&style::CustomTileLoader::fetchTile, id.canonical, actor.self());
+            loader.invoke(&style::CustomTileLoader::fetchTile, id, actor.self());
         } else if(!isRenderable()) {
-            loader.invoke(&style::CustomTileLoader::cancelTile, id.canonical);
+            loader.invoke(&style::CustomTileLoader::cancelTile, id);
         }
     }
 }
diff --git a/src/mbgl/tile/custom_tile.hpp b/src/mbgl/tile/custom_tile.hpp
index 734ea2bac1..7973d57a0b 100644
--- a/src/mbgl/tile/custom_tile.hpp
+++ b/src/mbgl/tile/custom_tile.hpp
@@ -19,7 +19,7 @@ public:
                const style::GeoJSONOptions,
                ActorRef<style::CustomTileLoader> loader);
     ~CustomTile() override;
-    void setTileData(const CanonicalTileID& tileID, const mapbox::geojson::geojson& data);
+    void setTileData(const mapbox::geojson::geojson& data);
 
     void setNecessity(Necessity) final;