[core] Runtime style layer API

7 files changed, 39 insertions, 40 deletions

diff --git a/src/mbgl/tile/raster_tile_data.cpp b/src/mbgl/tile/raster_tile_data.cpp
index 29b7ca6af8..a5eab3fb23 100644
--- a/src/mbgl/tile/raster_tile_data.cpp
+++ b/src/mbgl/tile/raster_tile_data.cpp
@@ -61,7 +61,7 @@ RasterTileData::~RasterTileData() {
     cancel();
 }
 
-Bucket* RasterTileData::getBucket(StyleLayer const&) {
+Bucket* RasterTileData::getBucket(const Layer&) {
     return bucket.get();
 }
 
diff --git a/src/mbgl/tile/raster_tile_data.hpp b/src/mbgl/tile/raster_tile_data.hpp
index 74e0cc400d..ea9b144e25 100644
--- a/src/mbgl/tile/raster_tile_data.hpp
+++ b/src/mbgl/tile/raster_tile_data.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class FileSource;
 class AsyncRequest;
-class StyleLayer;
+class Layer;
 namespace gl { class TexturePool; }
 
 class RasterTileData : public TileData {
@@ -22,7 +22,7 @@ public:
     ~RasterTileData();
 
     void cancel() override;
-    Bucket* getBucket(StyleLayer const &layer_desc) override;
+    Bucket* getBucket(const Layer&) override;
 
 private:
     gl::TexturePool& texturePool;
diff --git a/src/mbgl/tile/tile_data.hpp b/src/mbgl/tile/tile_data.hpp
index 297bfabcae..035a7ed319 100644
--- a/src/mbgl/tile/tile_data.hpp
+++ b/src/mbgl/tile/tile_data.hpp
@@ -16,7 +16,7 @@
 
 namespace mbgl {
 
-class StyleLayer;
+class Layer;
 class Worker;
 class DebugBucket;
 class TransformState;
@@ -29,7 +29,7 @@ public:
     // Mark this tile as no longer needed and cancel any pending work.
     virtual void cancel() = 0;
 
-    virtual Bucket* getBucket(const StyleLayer&) = 0;
+    virtual Bucket* getBucket(const Layer&) = 0;
 
     virtual bool parsePending(std::function<void (std::exception_ptr)>) { return true; }
     virtual void redoPlacement(PlacementConfig, const std::function<void()>&) {}
diff --git a/src/mbgl/tile/tile_worker.cpp b/src/mbgl/tile/tile_worker.cpp
index fdebe91229..9076684a2d 100644
--- a/src/mbgl/tile/tile_worker.cpp
+++ b/src/mbgl/tile/tile_worker.cpp
@@ -1,11 +1,11 @@
 #include <mbgl/text/collision_tile.hpp>
 #include <mbgl/tile/tile_worker.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
-#include <mbgl/style/style_layer.hpp>
 #include <mbgl/style/style_bucket_parameters.hpp>
 #include <mbgl/layer/background_layer.hpp>
 #include <mbgl/layer/custom_layer.hpp>
 #include <mbgl/layer/symbol_layer.hpp>
+#include <mbgl/layer/symbol_layer_impl.hpp>
 #include <mbgl/sprite/sprite_atlas.hpp>
 #include <mbgl/geometry/glyph_atlas.hpp>
 #include <mbgl/renderer/symbol_bucket.hpp>
@@ -37,7 +37,7 @@ TileWorker::~TileWorker() {
     glyphAtlas.removeGlyphs(reinterpret_cast<uintptr_t>(this));
 }
 
-TileParseResult TileWorker::parseAllLayers(std::vector<std::unique_ptr<StyleLayer>> layers_,
+TileParseResult TileWorker::parseAllLayers(std::vector<std::unique_ptr<Layer>> layers_,
                                            std::unique_ptr<const GeometryTile> geometryTile_,
                                            PlacementConfig config) {
     // We're doing a fresh parse of the tile, because the underlying data has changed.
@@ -55,12 +55,12 @@ TileParseResult TileWorker::parseAllLayers(std::vector<std::unique_ptr<StyleLaye
     std::set<std::string> parsed;
 
     for (auto i = layers.rbegin(); i != layers.rend(); i++) {
-        const StyleLayer* layer = i->get();
-        if (parsed.find(layer->bucketName()) == parsed.end()) {
-            parsed.emplace(layer->bucketName());
+        const Layer* layer = i->get();
+        if (parsed.find(layer->baseImpl->bucketName()) == parsed.end()) {
+            parsed.emplace(layer->baseImpl->bucketName());
             parseLayer(layer);
         }
-        featureIndex->addBucketLayerName(layer->bucketName(), layer->id);
+        featureIndex->addBucketLayerName(layer->baseImpl->bucketName(), layer->baseImpl->id);
     }
 
     return prepareResult(config);
@@ -70,16 +70,15 @@ TileParseResult TileWorker::parsePendingLayers(const PlacementConfig config) {
     // Try parsing the remaining layers that we couldn't parse in the first step due to missing
     // dependencies.
     for (auto it = pending.begin(); it != pending.end();) {
-        auto& layer = *it->first;
-        auto bucket = dynamic_cast<SymbolBucket*>(it->second.get());
-        assert(bucket); // Only symbol layers can be pending, so the dynamic cast should never fail.
-
-        if (!bucket->needsDependencies(glyphStore, spriteStore)) {
-            bucket->addFeatures(reinterpret_cast<uintptr_t>(this),
-                                *layer.spriteAtlas,
-                                glyphAtlas,
-                                glyphStore);
-            placementPending.emplace(layer.bucketName(), std::move(it->second));
+        const SymbolLayer& symbolLayer = *it->first;
+        SymbolBucket* symbolBucket = dynamic_cast<SymbolBucket*>(it->second.get());
+
+        if (!symbolBucket->needsDependencies(glyphStore, spriteStore)) {
+            symbolBucket->addFeatures(reinterpret_cast<uintptr_t>(this),
+                                      *symbolLayer.impl->spriteAtlas,
+                                      glyphAtlas,
+                                      glyphStore);
+            placementPending.emplace(symbolLayer.impl->bucketName(), std::move(it->second));
             pending.erase(it++);
             continue;
         }
@@ -120,7 +119,7 @@ std::unique_ptr<CollisionTile> TileWorker::redoPlacement(
     auto collisionTile = std::make_unique<CollisionTile>(config);
 
     for (auto i = layers.rbegin(); i != layers.rend(); i++) {
-        const auto it = buckets->find((*i)->id);
+        const auto it = buckets->find((*i)->baseImpl->id);
         if (it != buckets->end()) {
             it->second->placeFeatures(*collisionTile);
         }
@@ -129,7 +128,7 @@ std::unique_ptr<CollisionTile> TileWorker::redoPlacement(
     return collisionTile;
 }
 
-void TileWorker::parseLayer(const StyleLayer* layer) {
+void TileWorker::parseLayer(const Layer* layer) {
     // Cancel early when parsing.
     if (obsolete)
         return;
@@ -139,19 +138,19 @@ void TileWorker::parseLayer(const StyleLayer* layer) {
         return;
 
     // Skip this bucket if we are to not render this
-    if ((layer->source != sourceID) ||
-        (id.overscaledZ < std::floor(layer->minZoom)) ||
-        (id.overscaledZ >= std::ceil(layer->maxZoom)) ||
-        (layer->visibility == VisibilityType::None)) {
+    if ((layer->baseImpl->source != sourceID) ||
+        (id.overscaledZ < std::floor(layer->baseImpl->minZoom)) ||
+        (id.overscaledZ >= std::ceil(layer->baseImpl->maxZoom)) ||
+        (layer->baseImpl->visibility == VisibilityType::None)) {
         return;
     }
 
-    auto geometryLayer = geometryTile->getLayer(layer->sourceLayer);
+    auto geometryLayer = geometryTile->getLayer(layer->baseImpl->sourceLayer);
     if (!geometryLayer) {
         // The layer specified in the bucket does not exist. Do nothing.
         if (debug::tileParseWarnings) {
             Log::Warning(Event::ParseTile, "layer '%s' does not exist in tile %s",
-                    layer->sourceLayer.c_str(), util::toString(id).c_str());
+                    layer->baseImpl->sourceLayer.c_str(), util::toString(id).c_str());
         }
         return;
     }
@@ -167,17 +166,17 @@ void TileWorker::parseLayer(const StyleLayer* layer) {
                                      *featureIndex,
                                      mode);
 
-    std::unique_ptr<Bucket> bucket = layer->createBucket(parameters);
+    std::unique_ptr<Bucket> bucket = layer->baseImpl->createBucket(parameters);
 
     if (layer->is<SymbolLayer>()) {
         if (partialParse) {
             // We cannot parse this bucket yet. Instead, we're saving it for later.
             pending.emplace_back(layer->as<SymbolLayer>(), std::move(bucket));
         } else {
-            placementPending.emplace(layer->bucketName(), std::move(bucket));
+            placementPending.emplace(layer->baseImpl->bucketName(), std::move(bucket));
         }
     } else {
-        insertBucket(layer->bucketName(), std::move(bucket));
+        insertBucket(layer->baseImpl->bucketName(), std::move(bucket));
     }
 }
 
diff --git a/src/mbgl/tile/tile_worker.hpp b/src/mbgl/tile/tile_worker.hpp
index 83bf6c7f43..a04ef6a78f 100644
--- a/src/mbgl/tile/tile_worker.hpp
+++ b/src/mbgl/tile/tile_worker.hpp
@@ -23,7 +23,7 @@ class SpriteStore;
 class GlyphAtlas;
 class GlyphStore;
 class Bucket;
-class StyleLayer;
+class Layer;
 class SymbolLayer;
 
 // We're using this class to shuttle the resulting buckets from the worker thread to the MapContext
@@ -51,7 +51,7 @@ public:
                const MapMode);
     ~TileWorker();
 
-    TileParseResult parseAllLayers(std::vector<std::unique_ptr<StyleLayer>>,
+    TileParseResult parseAllLayers(std::vector<std::unique_ptr<Layer>>,
                                    std::unique_ptr<const GeometryTile> geometryTile,
                                    PlacementConfig);
 
@@ -62,7 +62,7 @@ public:
 
 private:
     TileParseResult prepareResult(const PlacementConfig& config);
-    void parseLayer(const StyleLayer*);
+    void parseLayer(const Layer*);
     void insertBucket(const std::string& name, std::unique_ptr<Bucket>);
     std::unique_ptr<CollisionTile> placeLayers(PlacementConfig);
 
@@ -77,7 +77,7 @@ private:
 
     bool partialParse = false;
 
-    std::vector<std::unique_ptr<StyleLayer>> layers;
+    std::vector<std::unique_ptr<Layer>> layers;
 
     std::unique_ptr<FeatureIndex> featureIndex;
     std::unique_ptr<const GeometryTile> geometryTile;
diff --git a/src/mbgl/tile/vector_tile_data.cpp b/src/mbgl/tile/vector_tile_data.cpp
index 428c605f26..db0ec8029e 100644
--- a/src/mbgl/tile/vector_tile_data.cpp
+++ b/src/mbgl/tile/vector_tile_data.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/tile/vector_tile_data.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
-#include <mbgl/style/style_layer.hpp>
+#include <mbgl/layer/layer_impl.hpp>
 #include <mbgl/util/worker.hpp>
 #include <mbgl/util/work_request.hpp>
 #include <mbgl/style/style.hpp>
@@ -139,8 +139,8 @@ bool VectorTileData::parsePending(std::function<void(std::exception_ptr)> callba
     return true;
 }
 
-Bucket* VectorTileData::getBucket(const StyleLayer& layer) {
-    const auto it = buckets.find(layer.bucketName());
+Bucket* VectorTileData::getBucket(const Layer& layer) {
+    const auto it = buckets.find(layer.baseImpl->bucketName());
     if (it == buckets.end()) {
         return nullptr;
     }
diff --git a/src/mbgl/tile/vector_tile_data.hpp b/src/mbgl/tile/vector_tile_data.hpp
index 2545df801b..4695338e1e 100644
--- a/src/mbgl/tile/vector_tile_data.hpp
+++ b/src/mbgl/tile/vector_tile_data.hpp
@@ -27,7 +27,7 @@ public:
 
     ~VectorTileData();
 
-    Bucket* getBucket(const StyleLayer&) override;
+    Bucket* getBucket(const Layer&) override;
 
     bool parsePending(std::function<void(std::exception_ptr)> callback) override;