[core] Instead of reusing GeoJSONOptions use - CustomVectorSource::Options and CustomVectorSource::TileOptions

7 files changed, 47 insertions, 45 deletions

diff --git a/include/mbgl/style/sources/custom_vector_source.hpp b/include/mbgl/style/sources/custom_vector_source.hpp
index c65a9992d8..1a3ed12931 100644
--- a/include/mbgl/style/sources/custom_vector_source.hpp
+++ b/include/mbgl/style/sources/custom_vector_source.hpp
@@ -1,25 +1,24 @@
 #pragma once
 
 #include <mbgl/style/source.hpp>
-#include <mbgl/style/sources/geojson_source.hpp>
-#include <mbgl/util/geo.hpp>
 #include <mbgl/util/geojson.hpp>
+#include <mbgl/util/range.hpp>
+#include <mbgl/util/constants.hpp>
 #include <mbgl/actor/actor_ref.hpp>
 
 namespace mbgl {
 
 class OverscaledTileID;
+class CanonicalTileID;
 
 namespace style {
 
-struct Error { std::string message; };
-
 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(TileFunction fetchTileFn, TileFunction cancelTileFn);
     ~CustomTileLoader();
 
     void fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef);
@@ -35,13 +34,23 @@ private:
 
 class CustomVectorSource : public Source {
 public:
-    CustomVectorSource(std::string id,
-                       GeoJSONOptions options,
-                       TileFunction fetchTile,
-                       TileFunction cancelTile);
+    struct TileOptions {
+        double tolerance = 0.375;
+        uint16_t tileSize = util::tileSize;
+        uint16_t buffer = 128;
+    };
+
+    struct Options {
+        TileFunction fetchTileFunction;
+        TileFunction cancelTileFunction;
+        Range<uint8_t> zoomRange = { 0, 18};
+        TileOptions tileOptions;
+    };
+public:
+    CustomVectorSource(std::string id, CustomVectorSource::Options options);
 
     void loadDescription(FileSource&) final;
-    void setTileData(const CanonicalTileID&, const mapbox::geojson::geojson& geojson);
+    void setTileData(const CanonicalTileID&, const mapbox::geojson::geojson&);
 
     // Private implementation
     class Impl;
diff --git a/src/mbgl/renderer/sources/render_custom_vector_source.cpp b/src/mbgl/renderer/sources/render_custom_vector_source.cpp
index 76cc649834..e99fdc45f2 100644
--- a/src/mbgl/renderer/sources/render_custom_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_custom_vector_source.cpp
@@ -33,21 +33,19 @@ void RenderCustomVectorSource::update(Immutable<style::Source::Impl> baseImpl_,
     enabled = needsRendering;
 
     auto tileLoader = impl().getTileLoader();
-    
     if (!tileLoader) {
         return;
     }
 
-    const GeoJSONOptions options = impl().getOptions();
     tilePyramid.update(layers,
                        needsRendering,
                        needsRelayout,
                        parameters,
                        SourceType::CustomVector,
                        util::tileSize,
-                       { options.minzoom, options.maxzoom },
+                       impl().getZoomRange(),
                        [&] (const OverscaledTileID& tileID) {
-                           return std::make_unique<CustomTile>(tileID, impl().id, parameters, impl().getOptions(), *tileLoader);
+                           return std::make_unique<CustomTile>(tileID, impl().id, parameters, impl().getTileOptions(), *tileLoader);
                        });
 }
 
diff --git a/src/mbgl/style/sources/custom_vector_source.cpp b/src/mbgl/style/sources/custom_vector_source.cpp
index 09e69e3e53..7a1e6049da 100644
--- a/src/mbgl/style/sources/custom_vector_source.cpp
+++ b/src/mbgl/style/sources/custom_vector_source.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/style/sources/custom_vector_source.hpp>
 #include <mbgl/style/sources/custom_vector_source_impl.hpp>
 #include <mbgl/actor/scheduler.hpp>
+#include <mbgl/tile/tile_id.hpp>
 
 #include <tuple>
 #include <map>
@@ -66,7 +67,7 @@ public:
     void setTileData(const CanonicalTileID& tileID, const mapbox::geojson::geojson& data) {
         auto iter = tileCallbackMap.find(tileID);
         if (iter == tileCallbackMap.end()) return;
-        dataCache[tileID] = std::make_unique<mapbox::geojson::geojson>(data);
+        dataCache[tileID] = std::make_unique<mapbox::geojson::geojson>(std::move(data));
         for(auto tuple : iter->second) {
             auto actor = std::get<2>(tuple);
             actor.invoke(&SetTileDataFunction::operator(), data);
@@ -80,7 +81,7 @@ private:
     std::map<CanonicalTileID, std::unique_ptr<mapbox::geojson::geojson>> dataCache;
 };
 
-CustomTileLoader::CustomTileLoader(TileFunction&& fetchTileFn, TileFunction&& cancelTileFn)
+CustomTileLoader::CustomTileLoader(TileFunction fetchTileFn, TileFunction cancelTileFn)
     : impl(new CustomTileLoader::Impl(std::move(fetchTileFn), std::move(cancelTileFn))) {
 
 }
@@ -107,12 +108,10 @@ void CustomTileLoader::removeTile(const OverscaledTileID& tileID) {
 }
 
 CustomVectorSource::CustomVectorSource(std::string id,
-                                       const GeoJSONOptions options,
-                                       TileFunction fetchTileFn,
-                                       TileFunction cancelTileFn)
+                                       const CustomVectorSource::Options options)
     : Source(makeMutable<CustomVectorSource::Impl>(std::move(id), options)),
     mailbox(std::make_shared<Mailbox>(*Scheduler::GetCurrent())),
-    loader(std::move(fetchTileFn), std::move(cancelTileFn)) {
+    loader(options.fetchTileFunction, options.cancelTileFunction) {
 }
 
 const CustomVectorSource::Impl& CustomVectorSource::impl() const {
diff --git a/src/mbgl/style/sources/custom_vector_source_impl.cpp b/src/mbgl/style/sources/custom_vector_source_impl.cpp
index d1f20045cb..82e985b5d5 100644
--- a/src/mbgl/style/sources/custom_vector_source_impl.cpp
+++ b/src/mbgl/style/sources/custom_vector_source_impl.cpp
@@ -1,23 +1,21 @@
 #include <mbgl/style/sources/custom_vector_source_impl.hpp>
-
 #include <mbgl/style/source_observer.hpp>
-#include <mbgl/tile/geojson_tile.hpp>
-#include <mbgl/tile/vector_tile.hpp>
-#include <mbgl/util/tile_cover.hpp>
 
 namespace mbgl {
 namespace style {
 
 CustomVectorSource::Impl::Impl(std::string id_,
-                               const GeoJSONOptions options_)
+                               const CustomVectorSource::Options options)
     : Source::Impl(SourceType::CustomVector, std::move(id_)),
-      options(options_),
+      tileOptions(options.tileOptions),
+      zoomRange(options.zoomRange),
       loaderRef({}) {
 }
 
 CustomVectorSource::Impl::Impl(const Impl& impl, ActorRef<CustomTileLoader> loaderRef_)
     : Source::Impl(impl),
-    options(impl.options),
+    tileOptions(impl.tileOptions),
+    zoomRange(impl.zoomRange),
     loaderRef(loaderRef_){
     
 }
@@ -26,8 +24,12 @@ optional<std::string> CustomVectorSource::Impl::getAttribution() const {
     return {};
 }
 
-GeoJSONOptions CustomVectorSource::Impl::getOptions() const {
-    return options;
+CustomVectorSource::TileOptions CustomVectorSource::Impl::getTileOptions() const {
+    return tileOptions;
+}
+
+Range<uint8_t> CustomVectorSource::Impl::getZoomRange() const {
+    return zoomRange;
 }
 
 optional<ActorRef<CustomTileLoader>> CustomVectorSource::Impl::getTileLoader() const {
diff --git a/src/mbgl/style/sources/custom_vector_source_impl.hpp b/src/mbgl/style/sources/custom_vector_source_impl.hpp
index af103f4c7e..90c7b4a76e 100644
--- a/src/mbgl/style/sources/custom_vector_source_impl.hpp
+++ b/src/mbgl/style/sources/custom_vector_source_impl.hpp
@@ -2,7 +2,6 @@
 
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/sources/custom_vector_source.hpp>
-#include <mbgl/tile/tile_id.hpp>
 #include <mbgl/actor/actor_ref.hpp>
 
 namespace mbgl {
@@ -10,16 +9,18 @@ namespace style {
 
 class CustomVectorSource::Impl : public Source::Impl {
 public:
-    Impl(std::string id, GeoJSONOptions options);
+    Impl(std::string id, CustomVectorSource::Options options);
     Impl(const Impl&, ActorRef<CustomTileLoader>);
 
     optional<std::string> getAttribution() const final;
 
-    GeoJSONOptions getOptions() const;
+    CustomVectorSource::TileOptions getTileOptions() const;
+    Range<uint8_t> getZoomRange() const;
     optional<ActorRef<CustomTileLoader>> getTileLoader() const;
 
 private:
-    GeoJSONOptions options;
+    CustomVectorSource::TileOptions tileOptions;
+    Range<uint8_t> zoomRange;
     optional<ActorRef<CustomTileLoader>> loaderRef;
 };
 
diff --git a/src/mbgl/tile/custom_tile.cpp b/src/mbgl/tile/custom_tile.cpp
index 9aa06f4838..890f6a4660 100644
--- a/src/mbgl/tile/custom_tile.cpp
+++ b/src/mbgl/tile/custom_tile.cpp
@@ -10,12 +10,11 @@
 #include <mapbox/geojsonvt.hpp>
 
 namespace mbgl {
-namespace style {
 
 CustomTile::CustomTile(const OverscaledTileID& overscaledTileID,
                          std::string sourceID_,
                          const TileParameters& parameters,
-                         const style::GeoJSONOptions options_,
+                         const style::CustomVectorSource::TileOptions options_,
                          ActorRef<style::CustomTileLoader> loader_)
     : GeometryTile(overscaledTileID, sourceID_, parameters),
     necessity(Resource::Optional),
@@ -34,13 +33,11 @@ void CustomTile::setTileData(const mapbox::geojson::geojson& geoJSON) {
     if (geoJSON.is<FeatureCollection>() && !geoJSON.get<FeatureCollection>().empty()) {
         const double scale = util::EXTENT / options.tileSize;
 
-        mapbox::geojsonvt::Options vtOptions;
-        vtOptions.maxZoom = options.maxzoom;
+        mapbox::geojsonvt::TileOptions vtOptions;
         vtOptions.extent = util::EXTENT;
         vtOptions.buffer = std::round(scale * options.buffer);
         vtOptions.tolerance = scale * options.tolerance;
-        auto geojsonVt = std::make_unique<mapbox::geojsonvt::GeoJSONVT>(geoJSON, vtOptions);
-        featureData = geojsonVt->getTile(id.canonical.z, id.canonical.x, id.canonical.y).features;
+        featureData = mapbox::geojsonvt::geoJSONToTile(geoJSON, id.canonical.z, id.canonical.x, id.canonical.y, vtOptions).features;
     }
     setData(std::make_unique<GeoJSONTileData>(std::move(featureData)));
 }
@@ -78,5 +75,4 @@ void CustomTile::querySourceFeatures(
     }
 }
 
-} // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/tile/custom_tile.hpp b/src/mbgl/tile/custom_tile.hpp
index aaf44cb378..039600e7a7 100644
--- a/src/mbgl/tile/custom_tile.hpp
+++ b/src/mbgl/tile/custom_tile.hpp
@@ -9,14 +9,12 @@ namespace mbgl {
 
 class TileParameters;
 
-namespace style {
-
 class CustomTile: public GeometryTile {
 public:
     CustomTile(const OverscaledTileID&,
                std::string sourceID,
                const TileParameters&,
-               const style::GeoJSONOptions,
+               const style::CustomVectorSource::TileOptions,
                ActorRef<style::CustomTileLoader> loader);
     ~CustomTile() override;
     void setTileData(const mapbox::geojson::geojson& data);
@@ -29,10 +27,9 @@ public:
 
 private:
     Necessity necessity;
-    const style::GeoJSONOptions options;
+    const style::CustomVectorSource::TileOptions options;
     ActorRef<style::CustomTileLoader> loader;
     Actor<style::SetTileDataFunction> actor;
 };
 
-} // namespace style
 } // namespace mbgl