setFeatureState for LineBucket

8 files changed, 54 insertions, 5 deletions

diff --git a/include/mbgl/util/feature.hpp b/include/mbgl/util/feature.hpp
index 4eeceda94..011ad1126 100644
--- a/include/mbgl/util/feature.hpp
+++ b/include/mbgl/util/feature.hpp
@@ -11,6 +11,8 @@ using NullValue = mapbox::geometry::null_value_t;
 using PropertyMap = mapbox::geometry::property_map;
 using FeatureIdentifier = mapbox::geometry::identifier;
 using Feature = mapbox::geometry::feature<double>;
+using FeatureStates = std::unordered_map<FeatureIdentifier, PropertyMap>;
+using FeatureStatesMap = std::unordered_map<std::string, FeatureStates>;
 
 template <class T>
 optional<T> numericValue(const Value& value) {
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index dd9460274..73adaa332 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -52,6 +52,10 @@ public:
     virtual void populateFeatureBuffers(const ImagePositions&) {};
     virtual void addPatternDependencies(const std::vector<const RenderLayer*>&, ImageDependencies&) {};
 
+    virtual void setFeatureState(const GeometryTileData*,
+        const std::string&,
+        const FeatureStates&) {};
+
     // As long as this bucket has a Prepare render pass, this function is getting called. Typically,
     // this only happens once when the bucket is being rendered for the first time.
     virtual void upload(gl::Context&) = 0;
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index dfd5d9c17..1af36e87b 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -26,6 +26,9 @@ LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layo
             std::forward_as_tuple(
                 pair.second,
                 zoom));
+        if (pair.second.isFeatureStateDependent()) {
+            stateDependentLayers.emplace(pair.first);
+        }
     }
 }
 
@@ -49,6 +52,20 @@ void LineBucket::addFeature(const GeometryTileFeature& feature,
     }
 }
 
+void LineBucket::setFeatureState(const GeometryTileData* tileData,
+                        const std::string& sourceLayer,
+                        const FeatureStates& featureStates) {
+    if (featureStates.empty() || stateDependentLayers.empty()) { return; }
+
+    auto sourceLayerData = tileData->getLayer(sourceLayer);
+    if (sourceLayerData) {
+        for (auto& pair : paintPropertyBinders) {
+            if (stateDependentLayers.count(pair.first) > 0) {
+                pair.second.updateVertexVectors(featureStates,  *sourceLayerData);
+            }
+        }
+    }
+}
 
 /*
  * Sharp corners cause dashed lines to tilt because the distance along the line
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index d66bcd299..58ec00de2 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -36,6 +36,10 @@ public:
 
     bool hasData() const override;
 
+    void setFeatureState(const GeometryTileData*,
+                const std::string&,
+                const FeatureStates&) override;
+
     void upload(gl::Context&) override;
 
     float getQueryRadius(const RenderLayer&) const override;
@@ -49,8 +53,9 @@ public:
     optional<gl::VertexBuffer<LineLayoutVertex>> vertexBuffer;
     optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
 
+    //TODO: AHM: Can these two be combined? Also need to store if bucket needs to be re-uploaded
     std::map<std::string, LineProgram::PaintPropertyBinders> paintPropertyBinders;
-
+    std::set<std::string> stateDependentLayers;
 private:
     void addGeometry(const GeometryCoordinates&, const GeometryTileFeature&);
 
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index 89ab065a7..1e775e0ef 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -529,8 +529,7 @@ public:
         });
     }
 
-    bool updateVertexVectors(const std::vector<std::pair<FeatureIdentifier, PropertyMap>>& featureStates,
-        const GeometryTileLayer& layer) {
+    bool updateVertexVectors(const FeatureStates& featureStates, const GeometryTileLayer& layer) {
         bool dirty = false;
         for (const auto& pair : featureStates) {
             const auto& posArray = idMap[pair.first];
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 5b81156bc..f1c68e3ea 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -107,7 +107,7 @@ void GeometryTile::setLayers(const std::vector<Immutable<Layer::Impl>>& layers)
             layer->visibility == VisibilityType::None) {
             continue;
         }
-
+        sourceLayers.insert(std::make_pair(layer->id, layer->sourceLayer));
         impls.push_back(layer);
     }
 
@@ -123,6 +123,24 @@ void GeometryTile::setShowCollisionBoxes(const bool showCollisionBoxes_) {
     }
 }
 
+void GeometryTile::setFeatureState(std::shared_ptr<FeatureStatesMap> featureStatesMap_) {
+    if (featureStatesMap_->empty() || pending == true) {
+        return;
+    }
+
+    const auto tileData = latestFeatureIndex->getData();
+    for (auto& entry : buckets) {
+        auto& bucket = *entry.second;
+        if (!bucket.hasData()) { continue; }
+        const auto& sourceLayer = sourceLayers.at(entry.first);
+        const auto& perLayerFeatureStates = featureStates->find(sourceLayer);
+        if (perLayerFeatureStates != featureStates->end() &&
+            !perLayerFeatureStates->second.empty()) {
+            bucket.setFeatureState(tileData, sourceLayer, perLayerFeatureStates->second);
+        }
+    }
+}
+
 void GeometryTile::onLayout(LayoutResult result, const uint64_t resultCorrelationID) {
     loaded = true;
     renderable = true;
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index c5c7cb662..ee2e475cb 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -36,6 +36,8 @@ public:
     void setLayers(const std::vector<Immutable<style::Layer::Impl>>&) override;
     void setShowCollisionBoxes(const bool showCollisionBoxes) override;
 
+    void setFeatureState(std::shared_ptr<FeatureStatesMap>) override;
+
     void onGlyphsAvailable(GlyphMap) override;
     void onImagesAvailable(ImageMap, ImageMap, uint64_t imageCorrelationID) override;
     
@@ -113,7 +115,8 @@ private:
     uint64_t correlationID = 0;
 
     std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
-    
+    std::unordered_map<std::string, std::string> sourceLayers;
+    std::shared_ptr<FeatureStatesMap> featureStates;
     std::shared_ptr<FeatureIndex> latestFeatureIndex;
 
     optional<AlphaImage> glyphAtlasImage;
diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp
index 70b2aa037..6f7f62c4f 100644
--- a/src/mbgl/tile/tile.hpp
+++ b/src/mbgl/tile/tile.hpp
@@ -63,6 +63,7 @@ public:
     virtual void setShowCollisionBoxes(const bool) {}
     virtual void setLayers(const std::vector<Immutable<style::Layer::Impl>>&) {}
     virtual void setMask(TileMask&&) {}
+    virtual void setFeatureState(std::shared_ptr<FeatureStatesMap>) {}
 
     virtual void queryRenderedFeatures(
             std::unordered_map<std::string, std::vector<Feature>>& result,