From 75d18e32fce61f4c20cc2fe78d4cdf5eb357ccca Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 16:21:46 +0300 Subject: [core] Add feature state support to expression --- src/mbgl/renderer/possibly_evaluated_property_value.hpp | 10 ++++++++++ src/mbgl/style/properties.hpp | 17 +++++++++++++++++ 2 files changed, 27 insertions(+) (limited to 'src') diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp index 625235011c..2e47e6c854 100644 --- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp +++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp @@ -49,6 +49,16 @@ public: } ); } + + template + T evaluate(const Feature& feature, float zoom, const FeatureState& featureState, T defaultValue) const { + return this->match( + [&] (const T& constant_) { return constant_; }, + [&] (const style::PropertyExpression& expression) { + return expression.evaluate(zoom, feature, featureState, defaultValue); + } + ); + } }; template diff --git a/src/mbgl/style/properties.hpp b/src/mbgl/style/properties.hpp index 9d66f850de..b07456a96d 100644 --- a/src/mbgl/style/properties.hpp +++ b/src/mbgl/style/properties.hpp @@ -180,11 +180,28 @@ public: }); } + template + static T evaluate(float z, const GeometryTileFeature& feature, const FeatureState& state, + const PossiblyEvaluatedPropertyValue& v, const T& defaultValue) { + return v.match( + [&] (const T& t) { + return t; + }, + [&] (const PropertyExpression& t) { + return t.evaluate(z, feature, state, defaultValue); + }); + } + template auto evaluate(float z, const GeometryTileFeature& feature) const { return evaluate(z, feature, this->template get

(), P::defaultValue()); } + template + auto evaluate(float z, const GeometryTileFeature& feature, const FeatureState& state) const { + return evaluate(z, feature, state, this->template get

(), P::defaultValue()); + } + Evaluated evaluate(float z, const GeometryTileFeature& feature) const { return Evaluated { evaluate(z, feature)... -- cgit v1.2.1 From 9e262ee55fdbc8b2e409a0d8a0da07841ef5eede Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 14:24:25 +0300 Subject: [core] Add feature state support to isFeatureConstant expression --- src/mbgl/style/expression/is_constant.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp index 9704168a41..5f8215c55f 100644 --- a/src/mbgl/style/expression/is_constant.cpp +++ b/src/mbgl/style/expression/is_constant.cpp @@ -20,7 +20,8 @@ bool isFeatureConstant(const Expression& expression) { } else if ( name == "properties" || name == "geometry-type" || - name == "id" + name == "id" || + name == "feature-state" ) { return false; } else if (0u == name.rfind(filter, 0u)) { -- cgit v1.2.1 From 91171bc1a98acf3d21704fa86ad7ada5d1ac762e Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 14:29:57 +0300 Subject: [core] Add feature-state compound expression --- src/mbgl/style/expression/compound_expression.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src') diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp index c637856ad9..8bd21bdad7 100644 --- a/src/mbgl/style/expression/compound_expression.cpp +++ b/src/mbgl/style/expression/compound_expression.cpp @@ -675,6 +675,20 @@ const auto& errorCompoundExpression() { return signature; } +const auto& featureStateCompoundExpression() { + static auto signature = detail::makeSignature("feature-state", [](const EvaluationContext& params, const std::string& key) -> Result { + mbgl::Value state; + if (params.featureState) { + auto it = params.featureState->find(key); + if (it != params.featureState->end()) { + state = mbgl::Value(it->second); + } + } + return toExpressionValue(state); + }); + return signature; +} + // Legacy Filters const auto& filterEqualsCompoundExpression() { static auto signature = detail::makeSignature("filter-==", [](const EvaluationContext& params, const std::string& key, const Value &lhs) -> Result { @@ -921,6 +935,7 @@ MAPBOX_ETERNAL_CONSTEXPR const auto compoundExpressionRegistry = mapbox::eternal { "concat", concatCompoundExpression }, { "resolved-locale", resolvedLocaleCompoundExpression }, { "error", errorCompoundExpression }, + { "feature-state", featureStateCompoundExpression }, // Legacy Filters { "filter-==", filterEqualsCompoundExpression }, { "filter-id-==", filterIdEqualsCompoundExpression }, -- cgit v1.2.1 From 413278ca20de77f7025b5304493dca6d1863fbb3 Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 16:03:36 +0300 Subject: [core] Add feature state support to bucket classes --- src/mbgl/gfx/vertex_vector.hpp | 5 + src/mbgl/layout/pattern_layout.hpp | 2 +- src/mbgl/layout/symbol_layout.cpp | 4 +- src/mbgl/renderer/bucket.hpp | 6 +- src/mbgl/renderer/buckets/circle_bucket.cpp | 19 +++- src/mbgl/renderer/buckets/circle_bucket.hpp | 5 +- src/mbgl/renderer/buckets/fill_bucket.cpp | 23 ++-- src/mbgl/renderer/buckets/fill_bucket.hpp | 5 +- .../renderer/buckets/fill_extrusion_bucket.cpp | 21 +++- .../renderer/buckets/fill_extrusion_bucket.hpp | 5 +- src/mbgl/renderer/buckets/heatmap_bucket.cpp | 5 +- src/mbgl/renderer/buckets/heatmap_bucket.hpp | 3 +- src/mbgl/renderer/buckets/line_bucket.cpp | 21 +++- src/mbgl/renderer/buckets/line_bucket.hpp | 5 +- src/mbgl/renderer/paint_property_binder.hpp | 119 +++++++++++++++++++-- src/mbgl/tile/geometry_tile_worker.cpp | 2 +- 16 files changed, 208 insertions(+), 42 deletions(-) (limited to 'src') diff --git a/src/mbgl/gfx/vertex_vector.hpp b/src/mbgl/gfx/vertex_vector.hpp index 59fe67586b..091ecb912e 100644 --- a/src/mbgl/gfx/vertex_vector.hpp +++ b/src/mbgl/gfx/vertex_vector.hpp @@ -20,6 +20,11 @@ public: v.resize(v.size() + n, val); } + Vertex& at(std::size_t n) { + assert(n < v.size()); + return v.at(n); + } + std::size_t elements() const { return v.size(); } diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp index 858d515347..d6d878955f 100644 --- a/src/mbgl/layout/pattern_layout.hpp +++ b/src/mbgl/layout/pattern_layout.hpp @@ -108,7 +108,7 @@ public: const PatternLayerMap& patterns = patternFeature.patterns; const GeometryCollection& geometries = feature->getGeometries(); - bucket->addFeature(*feature, geometries, patternPositions, patterns); + bucket->addFeature(*feature, geometries, patternPositions, patterns, i); featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID); } if (bucket->hasData()) { diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp index 1dbb5d91dc..71724cad5f 100644 --- a/src/mbgl/layout/symbol_layout.cpp +++ b/src/mbgl/layout/symbol_layout.cpp @@ -713,7 +713,7 @@ void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptrpaintProperties) { - pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(), {}, {}); + pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(), symbolInstance.dataFeatureIndex, {}, {}); } } @@ -765,7 +765,7 @@ void SymbolLayout::updatePaintPropertiesForSection(SymbolBucket& bucket, std::size_t sectionIndex) { const auto& formattedSection = sectionOptionsToValue((*feature.formattedText).sectionAt(sectionIndex)); for (auto& pair : bucket.paintProperties) { - pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), {}, {}, formattedSection); + pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), feature.index, {}, {}, formattedSection); } } diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index a978c06d6b..98c2200ce9 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -35,7 +35,11 @@ public: virtual void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, - const PatternLayerMap&) {}; + const PatternLayerMap&, + std::size_t) {}; + + virtual void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) {} + // 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. diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp index 7ba130da64..ffa6f59128 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.cpp +++ b/src/mbgl/renderer/buckets/circle_bucket.cpp @@ -25,8 +25,10 @@ CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector CircleBucket::~CircleBucket() = default; void CircleBucket::upload(gfx::UploadPass& uploadPass) { - vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); - indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + if (!uploaded) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + } for (auto& pair : paintPropertyBinders) { pair.second.upload(uploadPass); @@ -42,7 +44,8 @@ bool CircleBucket::hasData() const { void CircleBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, const ImagePositions&, - const PatternLayerMap&) { + const PatternLayerMap&, + std::size_t featureIndex) { constexpr const uint16_t vertexLength = 4; for (auto& circle : geometry) { @@ -90,7 +93,7 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature, } for (auto& pair : paintPropertyBinders) { - pair.second.populateVertexVectors(feature, vertices.elements(), {}, {}); + pair.second.populateVertexVectors(feature, vertices.elements(), featureIndex, {}, {}); } } @@ -112,4 +115,12 @@ float CircleBucket::getQueryRadius(const RenderLayer& layer) const { return radius + stroke + util::length(translate[0], translate[1]); } +void CircleBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { + auto it = paintPropertyBinders.find(layerID); + if (it != paintPropertyBinders.end()) { + it->second.updateVertexVectors(states, layer, imagePositions); + uploaded = false; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp index 27423bc568..9fee45ad79 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.hpp +++ b/src/mbgl/renderer/buckets/circle_bucket.hpp @@ -21,7 +21,8 @@ public: void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, - const PatternLayerMap&) override; + const PatternLayerMap&, + std::size_t) override; bool hasData() const override; @@ -29,6 +30,8 @@ public: float getQueryRadius(const RenderLayer&) const override; + void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override; + gfx::VertexVector vertices; gfx::IndexVector triangles; SegmentVector segments; diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp index 8a089c679e..ea79a1e687 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_bucket.cpp @@ -47,7 +47,8 @@ FillBucket::~FillBucket() = default; void FillBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies) { + const PatternLayerMap& patternDependencies, + std::size_t index) { for (auto& polygon : classifyRings(geometry)) { // Optimize polygons with many interior rings for earcut tesselation. limitHoles(polygon, 500); @@ -114,17 +115,19 @@ void FillBucket::addFeature(const GeometryTileFeature& feature, for (auto& pair : paintPropertyBinders) { const auto it = patternDependencies.find(pair.first); if (it != patternDependencies.end()){ - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, it->second); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, it->second); } else { - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, {}); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, {}); } } } void FillBucket::upload(gfx::UploadPass& uploadPass) { - vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); - lineIndexBuffer = uploadPass.createIndexBuffer(std::move(lines)); - triangleIndexBuffer = triangles.empty() ? optional {} : uploadPass.createIndexBuffer(std::move(triangles)); + if (!uploaded) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + lineIndexBuffer = uploadPass.createIndexBuffer(std::move(lines)); + triangleIndexBuffer = triangles.empty() ? optional {} : uploadPass.createIndexBuffer(std::move(triangles)); + } for (auto& pair : paintPropertyBinders) { pair.second.upload(uploadPass); @@ -143,4 +146,12 @@ float FillBucket::getQueryRadius(const RenderLayer& layer) const { return util::length(translate[0], translate[1]); } +void FillBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { + auto it = paintPropertyBinders.find(layerID); + if (it != paintPropertyBinders.end()) { + it->second.updateVertexVectors(states, layer, imagePositions); + uploaded = false; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp index 6747c1083f..eee421f938 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_bucket.hpp @@ -29,7 +29,8 @@ public: void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&, - const PatternLayerMap&) override; + const PatternLayerMap&, + std::size_t) override; bool hasData() const override; @@ -37,6 +38,8 @@ public: float getQueryRadius(const RenderLayer&) const override; + void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override; + gfx::VertexVector vertices; gfx::IndexVector lines; gfx::IndexVector triangles; diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp index be13850e55..6a25349c22 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp @@ -53,7 +53,8 @@ FillExtrusionBucket::~FillExtrusionBucket() = default; void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies) { + const PatternLayerMap& patternDependencies, + std::size_t index) { for (auto& polygon : classifyRings(geometry)) { // Optimize polygons with many interior rings for earcut tesselation. limitHoles(polygon, 500); @@ -158,16 +159,18 @@ void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, for (auto& pair : paintPropertyBinders) { const auto it = patternDependencies.find(pair.first); if (it != patternDependencies.end()){ - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, it->second); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, it->second); } else { - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, {}); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, {}); } } } void FillExtrusionBucket::upload(gfx::UploadPass& uploadPass) { - vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); - indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + if (!uploaded) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + } for (auto& pair : paintPropertyBinders) { pair.second.upload(uploadPass); @@ -186,4 +189,12 @@ float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const { return util::length(translate[0], translate[1]); } +void FillExtrusionBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { + auto it = paintPropertyBinders.find(layerID); + if (it != paintPropertyBinders.end()) { + it->second.updateVertexVectors(states, layer, imagePositions); + uploaded = false; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp index 4c97618a77..582480bf41 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp @@ -27,7 +27,8 @@ public: void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&, - const PatternLayerMap&) override; + const PatternLayerMap&, + std::size_t) override; bool hasData() const override; @@ -35,6 +36,8 @@ public: float getQueryRadius(const RenderLayer&) const override; + void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override; + gfx::VertexVector vertices; gfx::IndexVector triangles; SegmentVector triangleSegments; diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp index fad78f6cec..0ea645a9a0 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp @@ -42,7 +42,8 @@ bool HeatmapBucket::hasData() const { void HeatmapBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, const ImagePositions&, - const PatternLayerMap&) { + const PatternLayerMap&, + std::size_t featureIndex) { constexpr const uint16_t vertexLength = 4; for (auto& points : geometry) { @@ -89,7 +90,7 @@ void HeatmapBucket::addFeature(const GeometryTileFeature& feature, } for (auto& pair : paintPropertyBinders) { - pair.second.populateVertexVectors(feature, vertices.elements(), {}, {}); + pair.second.populateVertexVectors(feature, vertices.elements(), featureIndex, {}, {}); } } diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp index 68790bf5bf..3f9d1cb5c3 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp @@ -21,7 +21,8 @@ public: void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, - const PatternLayerMap&) override; + const PatternLayerMap&, + std::size_t) override; bool hasData() const override; void upload(gfx::UploadPass&) override; diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp index 9019e76d3b..318af99b0f 100644 --- a/src/mbgl/renderer/buckets/line_bucket.cpp +++ b/src/mbgl/renderer/buckets/line_bucket.cpp @@ -33,7 +33,8 @@ LineBucket::~LineBucket() = default; void LineBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometryCollection, const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies) { + const PatternLayerMap& patternDependencies, + std::size_t index) { for (auto& line : geometryCollection) { addGeometry(line, feature); } @@ -41,9 +42,9 @@ void LineBucket::addFeature(const GeometryTileFeature& feature, for (auto& pair : paintPropertyBinders) { const auto it = patternDependencies.find(pair.first); if (it != patternDependencies.end()){ - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, it->second); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, it->second); } else { - pair.second.populateVertexVectors(feature, vertices.elements(), patternPositions, {}); + pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, {}); } } } @@ -517,8 +518,10 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex, } void LineBucket::upload(gfx::UploadPass& uploadPass) { - vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); - indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + if (!uploaded) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); + } for (auto& pair : paintPropertyBinders) { pair.second.upload(uploadPass); @@ -554,4 +557,12 @@ float LineBucket::getQueryRadius(const RenderLayer& layer) const { return lineWidth / 2.0f + std::abs(offset) + util::length(translate[0], translate[1]); } +void LineBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { + auto it = paintPropertyBinders.find(layerID); + if (it != paintPropertyBinders.end()) { + it->second.updateVertexVectors(states, layer, imagePositions); + uploaded = false; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp index eac9e14e4c..6be35593d9 100644 --- a/src/mbgl/renderer/buckets/line_bucket.hpp +++ b/src/mbgl/renderer/buckets/line_bucket.hpp @@ -29,7 +29,8 @@ public: void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions& patternPositions, - const PatternLayerMap&) override; + const PatternLayerMap&, + std::size_t) override; bool hasData() const override; @@ -37,6 +38,8 @@ public: float getQueryRadius(const RenderLayer&) const override; + void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override; + PossiblyEvaluatedLayoutProperties layout; gfx::VertexVector vertices; diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp index cd6b259e88..fdfbc99642 100644 --- a/src/mbgl/renderer/paint_property_binder.hpp +++ b/src/mbgl/renderer/paint_property_binder.hpp @@ -19,6 +19,15 @@ namespace mbgl { +// Maps vertex range to feature index +struct FeatureVertexRange { + std::size_t featureIndex; + std::size_t start; + std::size_t end; +}; + +using FeatureVertexRangeMap = std::map>; + /* ZoomInterpolatedAttribute is a 'compound' attribute, representing two values of the the base attribute Attr. These two values are provided to the shader to allow interpolation @@ -97,9 +106,17 @@ public: virtual ~PaintPropertyBinder() = default; virtual void populateVertexVector(const GeometryTileFeature& feature, - std::size_t length, const ImagePositions&, + std::size_t length, std::size_t index, + const ImagePositions&, const optional&, const style::expression::Value&) = 0; + + virtual void updateVertexVectors(const FeatureStates&, + const GeometryTileLayer&, + const ImagePositions&) {} + + virtual void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) = 0; + virtual void upload(gfx::UploadPass&) = 0; virtual void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) = 0; virtual std::tuple>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0; @@ -118,7 +135,8 @@ public: : constant(std::move(constant_)) { } - void populateVertexVector(const GeometryTileFeature&, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {} void upload(gfx::UploadPass&) override {} void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; @@ -145,7 +163,8 @@ public: : constant(std::move(constant_)), constantPatternPositions({}) { } - void populateVertexVector(const GeometryTileFeature&, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {} void upload(gfx::UploadPass&) override {} void setPatternParameters(const optional& posA, const optional& posB, const CrossfadeParameters&) override { @@ -187,14 +206,46 @@ public: defaultValue(std::move(defaultValue_)) { } void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; - void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { + void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { using style::expression::EvaluationContext; auto evaluated = expression.evaluate(EvaluationContext(&feature).withFormattedSection(&formattedSection), defaultValue); this->statistics.add(evaluated); auto value = attributeValue(evaluated); - for (std::size_t i = vertexVector.elements(); i < length; ++i) { + auto elements = vertexVector.elements(); + for (std::size_t i = elements; i < length; ++i) { vertexVector.emplace_back(BaseVertex { value }); } + optional idStr = featureIDtoString(feature.getID()); + if (idStr) { + featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length }); + } + } + + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override { + for (const auto& it : states) { + const auto positions = featureMap.find(it.first); + if (positions == featureMap.end()) { + continue; + } + + for (const auto& pos : positions->second) { + std::unique_ptr feature = layer.getFeature(pos.featureIndex); + if (feature) { + updateVertexVector(pos.start, pos.end, *feature, it.second); + } + } + } + } + + void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override { + using style::expression::EvaluationContext; + + auto evaluated = expression.evaluate(EvaluationContext(&feature).withFeatureState(&state), defaultValue); + this->statistics.add(evaluated); + auto value = attributeValue(evaluated); + for (std::size_t i = start; i < end; ++i) { + vertexVector.at(i) = BaseVertex { value }; + } } void upload(gfx::UploadPass& uploadPass) override { @@ -229,6 +280,7 @@ private: T defaultValue; gfx::VertexVector vertexVector; optional> vertexBuffer; + FeatureVertexRangeMap featureMap; }; template @@ -245,7 +297,7 @@ public: zoomRange({zoom, zoom + 1}) { } void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; - void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { + void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { using style::expression::EvaluationContext; Range range = { expression.evaluate(EvaluationContext(zoomRange.min, &feature).withFormattedSection(&formattedSection), defaultValue), @@ -256,9 +308,47 @@ public: AttributeValue value = zoomInterpolatedAttributeValue( attributeValue(range.min), attributeValue(range.max)); - for (std::size_t i = vertexVector.elements(); i < length; ++i) { + auto elements = vertexVector.elements(); + for (std::size_t i = elements; i < length; ++i) { vertexVector.emplace_back(Vertex { value }); } + optional idStr = featureIDtoString(feature.getID()); + if (idStr) { + featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length }); + } + } + + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override { + for (const auto& it : states) { + const auto positions = featureMap.find(it.first); + if (positions == featureMap.end()) { + continue; + } + + for (const auto& pos : positions->second) { + std::unique_ptr feature = layer.getFeature(pos.featureIndex); + if (feature) { + updateVertexVector(pos.start, pos.end, *feature, it.second); + } + } + } + } + + void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override { + using style::expression::EvaluationContext; + Range range = { + expression.evaluate(EvaluationContext(zoomRange.min, &feature, &state), defaultValue), + expression.evaluate(EvaluationContext(zoomRange.max, &feature, &state), defaultValue), + }; + this->statistics.add(range.min); + this->statistics.add(range.max); + AttributeValue value = zoomInterpolatedAttributeValue( + attributeValue(range.min), + attributeValue(range.max)); + + for (std::size_t i = start; i < end; ++i) { + vertexVector.at(i) = Vertex { value }; + } } void upload(gfx::UploadPass& uploadPass) override { @@ -298,6 +388,7 @@ private: Range zoomRange; gfx::VertexVector vertexVector; optional> vertexBuffer; + FeatureVertexRangeMap featureMap; }; template @@ -322,7 +413,7 @@ public: crossfade = crossfade_; }; - void populateVertexVector(const GeometryTileFeature&, std::size_t length, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value&) override { + void populateVertexVector(const GeometryTileFeature&, std::size_t length, std::size_t /* index */, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value&) override { if (!patternDependencies || patternDependencies->mid.empty()) { // Unlike other propperties with expressions that evaluate to null, the default value for `*-pattern` properties is an empty @@ -353,6 +444,8 @@ public: } } + void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {} + void upload(gfx::UploadPass& uploadPass) override { if (!patternToVertexVector.empty()) { assert(!zoomInVertexVector.empty()); @@ -491,9 +584,15 @@ public: PaintPropertyBinders(PaintPropertyBinders&&) = default; PaintPropertyBinders(const PaintPropertyBinders&) = delete; - void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value& formattedSection = {}) { + void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value& formattedSection = {}) { + util::ignore({ + (binders.template get()->populateVertexVector(feature, length, index, patternPositions, patternDependencies, formattedSection), 0)... + }); + } + + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions& imagePositions) { util::ignore({ - (binders.template get()->populateVertexVector(feature, length, patternPositions, patternDependencies, formattedSection), 0)... + (binders.template get()->updateVertexVectors(states, layer, imagePositions), 0)... }); } diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp index 428a5b0d5e..ce883ad93f 100644 --- a/src/mbgl/tile/geometry_tile_worker.cpp +++ b/src/mbgl/tile/geometry_tile_worker.cpp @@ -384,7 +384,7 @@ void GeometryTileWorker::parse() { continue; const GeometryCollection& geometries = feature->getGeometries(); - bucket->addFeature(*feature, geometries, {}, PatternLayerMap ()); + bucket->addFeature(*feature, geometries, {}, PatternLayerMap (), i); featureIndex->insert(geometries, i, sourceLayerID, leaderImpl.id); } -- cgit v1.2.1 From 1ac8e3c16145b4ec4ee341ad8d407f389575e52c Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 15:27:01 +0300 Subject: [core] Add setFeatureState API to Tile classes --- src/mbgl/renderer/render_tile.cpp | 4 ++++ src/mbgl/renderer/render_tile.hpp | 3 +++ src/mbgl/tile/geometry_tile.cpp | 23 +++++++++++++++++++++++ src/mbgl/tile/geometry_tile.hpp | 2 ++ src/mbgl/tile/tile.hpp | 4 +++- 5 files changed, 35 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp index 65a6cb9f30..0d63e5b265 100644 --- a/src/mbgl/renderer/render_tile.cpp +++ b/src/mbgl/renderer/render_tile.cpp @@ -227,4 +227,8 @@ void RenderTile::finishRender(PaintParameters& parameters) const { } } +void RenderTile::setFeatureState(const LayerFeatureStates& states) { + tile.setFeatureState(states); +} + } // namespace mbgl diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp index 34d027cae5..483dbf7413 100644 --- a/src/mbgl/renderer/render_tile.hpp +++ b/src/mbgl/renderer/render_tile.hpp @@ -68,6 +68,9 @@ public: style::TranslateAnchorType anchor, const TransformState& state, const bool inViewportPixelUnits) const; + + void setFeatureState(const LayerFeatureStates&); + private: Tile& tile; // The following members are reset at placement stage. diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp index 3087b4fc6a..8f624f21dc 100644 --- a/src/mbgl/tile/geometry_tile.cpp +++ b/src/mbgl/tile/geometry_tile.cpp @@ -387,4 +387,27 @@ void GeometryTile::performedFadePlacement() { } } +void GeometryTile::setFeatureState(const LayerFeatureStates& states) { + auto layers = getData(); + if (!layers || states.empty() || !layoutResult) return; + + auto& layerIdToLayerRenderData = layoutResult->layerRenderData; + for (auto& layer : layerIdToLayerRenderData) { + const auto& layerID = layer.first; + const auto sourceLayer = layers->getLayer(layerID); + if (sourceLayer) { + const auto& sourceLayerID = sourceLayer->getName(); + auto entry = states.find(sourceLayerID); + if (entry == states.end()) continue; + const auto& featureStates = entry->second; + if (featureStates.empty()) continue; + + auto bucket = layer.second.bucket; + if (bucket && bucket->hasData()) { + bucket->update(featureStates, *sourceLayer, layerID, layoutResult->iconAtlas.patternPositions); + } + } + } +} + } // namespace mbgl diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp index 8682c8c76b..ca9e33218c 100644 --- a/src/mbgl/tile/geometry_tile.hpp +++ b/src/mbgl/tile/geometry_tile.hpp @@ -94,6 +94,8 @@ public: const std::string sourceID; + void setFeatureState(const LayerFeatureStates&) override; + protected: const GeometryTileData* getData() const; LayerRenderData* getLayerRenderData(const style::Layer::Impl&); diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp index 7a7d246aa6..65bff305a3 100644 --- a/src/mbgl/tile/tile.hpp +++ b/src/mbgl/tile/tile.hpp @@ -125,7 +125,9 @@ public: // We hold onto a tile for two placements: fading starts with the first placement // and will have time to finish by the second placement. virtual void performedFadePlacement() {} - + + virtual void setFeatureState(const LayerFeatureStates&) {} + void dumpDebugLogs() const; const Kind kind; -- cgit v1.2.1 From 46eab5f1488570262b218dfaec99c476829ab21f Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 14:35:50 +0300 Subject: [core] Add SourceFeatureState class to handle feature states --- src/core-files.json | 2 ++ src/mbgl/renderer/source_state.cpp | 69 ++++++++++++++++++++++++++++++++++++++ src/mbgl/renderer/source_state.hpp | 26 ++++++++++++++ 3 files changed, 97 insertions(+) create mode 100644 src/mbgl/renderer/source_state.cpp create mode 100644 src/mbgl/renderer/source_state.hpp (limited to 'src') diff --git a/src/core-files.json b/src/core-files.json index f4f2dd2c40..4867bd3dc4 100644 --- a/src/core-files.json +++ b/src/core-files.json @@ -134,6 +134,7 @@ "src/mbgl/renderer/renderer.cpp", "src/mbgl/renderer/renderer_impl.cpp", "src/mbgl/renderer/renderer_state.cpp", + "src/mbgl/renderer/source_state.cpp", "src/mbgl/renderer/sources/render_custom_geometry_source.cpp", "src/mbgl/renderer/sources/render_geojson_source.cpp", "src/mbgl/renderer/sources/render_image_source.cpp", @@ -656,6 +657,7 @@ "mbgl/renderer/render_tile.hpp": "src/mbgl/renderer/render_tile.hpp", "mbgl/renderer/render_tree.hpp": "src/mbgl/renderer/render_tree.hpp", "mbgl/renderer/renderer_impl.hpp": "src/mbgl/renderer/renderer_impl.hpp", + "mbgl/renderer/source_state.hpp": "src/mbgl/renderer/source_state.hpp", "mbgl/renderer/sources/render_custom_geometry_source.hpp": "src/mbgl/renderer/sources/render_custom_geometry_source.hpp", "mbgl/renderer/sources/render_geojson_source.hpp": "src/mbgl/renderer/sources/render_geojson_source.hpp", "mbgl/renderer/sources/render_image_source.hpp": "src/mbgl/renderer/sources/render_image_source.hpp", diff --git a/src/mbgl/renderer/source_state.cpp b/src/mbgl/renderer/source_state.cpp new file mode 100644 index 0000000000..087e28b2bb --- /dev/null +++ b/src/mbgl/renderer/source_state.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include + +namespace mbgl { + +void SourceFeatureState::updateState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& newState) { + std::string sourceLayer = sourceLayerID.value_or(std::string()); + for (const auto& state : newState) { + auto& layerStates = stateChanges[sourceLayer]; + auto& featureStates = layerStates[featureID]; + featureStates[state.first] = state.second; + } +} + +void SourceFeatureState::getState(FeatureState& result, const optional& sourceLayerID, const std::string& featureID) const { + std::string sourceLayer = sourceLayerID.value_or(std::string()); + FeatureState current, changes; + auto layerStates = currentStates.find(sourceLayer); + if (layerStates != currentStates.end()) { + const auto currentStateEntry = layerStates->second.find(featureID); + if (currentStateEntry != layerStates->second.end()) { + current = currentStateEntry->second; + } + } + + layerStates = stateChanges.find(sourceLayer); + if (layerStates != stateChanges.end()) { + const auto stateChangesEntry = layerStates->second.find(featureID); + if (stateChangesEntry != layerStates->second.end()) { + changes = stateChangesEntry->second; + } + } + result = std::move(changes); + result.insert(current.begin(), current.end()); +} + +void SourceFeatureState::coalesceChanges(std::vector& tiles) { + LayerFeatureStates changes; + for (const auto& layerStatesEntry : stateChanges) { + const auto& sourceLayer = layerStatesEntry.first; + FeatureStates layerStates; + for (const auto& featureStatesEntry : stateChanges[sourceLayer]) { + const auto& featureID = featureStatesEntry.first; + for (const auto& stateEntry : stateChanges[sourceLayer][featureID]) { + const auto& stateKey = stateEntry.first; + const auto& stateVal = stateEntry.second; + + auto currentState = currentStates[sourceLayer][featureID].find(stateKey); + if (currentState != currentStates[sourceLayer][featureID].end()) { + currentState->second = stateVal; + } else { + currentStates[sourceLayer][featureID].insert(std::make_pair(stateKey, stateVal)); + } + } + layerStates[featureID] = currentStates[sourceLayer][featureID]; + } + changes[sourceLayer] = std::move(layerStates); + } + stateChanges.clear(); + if (changes.empty()) return; + + for (auto& tile : tiles) { + tile.setFeatureState(changes); + } +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/source_state.hpp b/src/mbgl/renderer/source_state.hpp new file mode 100644 index 0000000000..9944709b0d --- /dev/null +++ b/src/mbgl/renderer/source_state.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include +#include + +namespace mbgl { + +class RenderTile; +using namespace style::conversion; + +class SourceFeatureState { +public: + SourceFeatureState() = default; + ~SourceFeatureState() = default; + + void updateState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& newState); + void getState(FeatureState& result, const optional& sourceLayerID, const std::string& featureID) const; + + void coalesceChanges(std::vector& tiles); + +private: + LayerFeatureStates currentStates; + LayerFeatureStates stateChanges; +}; + +} // namespace mbgl -- cgit v1.2.1 From 8e19be9d9c7f66bff16f97066570e990fe09fd4e Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 14:39:36 +0300 Subject: [core] Add support for set/getFeatureState APIs --- src/mbgl/renderer/render_orchestrator.cpp | 18 ++++++++++++++++++ src/mbgl/renderer/render_orchestrator.hpp | 10 ++++++++++ src/mbgl/renderer/render_source.hpp | 8 ++++++++ src/mbgl/renderer/renderer.cpp | 14 ++++++++++++++ src/mbgl/renderer/sources/render_tile_source.cpp | 13 +++++++++++++ src/mbgl/renderer/sources/render_tile_source.hpp | 10 ++++++++++ 6 files changed, 73 insertions(+) (limited to 'src') diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp index a62ccb0a0a..fbf98500b4 100644 --- a/src/mbgl/renderer/render_orchestrator.cpp +++ b/src/mbgl/renderer/render_orchestrator.cpp @@ -562,6 +562,24 @@ FeatureExtensionValue RenderOrchestrator::queryFeatureExtensions(const std::stri return {}; } +void RenderOrchestrator::setFeatureState(const std::string& sourceID, + const optional& sourceLayerID, + const std::string& featureID, + const FeatureState& state) { + if (RenderSource* renderSource = getRenderSource(sourceID)) { + renderSource->setFeatureState(sourceLayerID, featureID, state); + } +} + +void RenderOrchestrator::getFeatureState(FeatureState& state, + const std::string& sourceID, + const optional& sourceLayerID, + const std::string& featureID) const { + if (RenderSource* renderSource = getRenderSource(sourceID)) { + renderSource->getFeatureState(state, sourceLayerID, featureID); + } +} + void RenderOrchestrator::reduceMemoryUse() { filteredLayersForSource.shrink_to_fit(); for (const auto& entry : renderSources) { diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp index 884bd21b7b..7467e0c7dd 100644 --- a/src/mbgl/renderer/render_orchestrator.hpp +++ b/src/mbgl/renderer/render_orchestrator.hpp @@ -64,6 +64,16 @@ public: const std::string& extensionField, const optional>& args) const; + void setFeatureState(const std::string& sourceID, + const optional& layerID, + const std::string& featureID, + const FeatureState& state); + + void getFeatureState(FeatureState& state, + const std::string& sourceID, + const optional& layerID, + const std::string& featureID) const; + void reduceMemoryUse(); void dumpDebugLogs(); diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp index cd471223a8..c803c82c95 100644 --- a/src/mbgl/renderer/render_source.hpp +++ b/src/mbgl/renderer/render_source.hpp @@ -93,6 +93,14 @@ public: return {}; } + virtual void setFeatureState(const optional&, + const std::string&, + const FeatureState&) {} + + virtual void getFeatureState(FeatureState&, + const optional&, + const std::string&) const {} + virtual void reduceMemoryUse() = 0; virtual void dumpDebugLogs() const = 0; diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp index 52cd7a4351..40b342b1d4 100644 --- a/src/mbgl/renderer/renderer.cpp +++ b/src/mbgl/renderer/renderer.cpp @@ -109,6 +109,20 @@ FeatureExtensionValue Renderer::queryFeatureExtensions(const std::string& source return impl->orchestrator.queryFeatureExtensions(sourceID, feature, extension, extensionField, args); } +void Renderer::setFeatureState(const std::string& sourceID, + const optional& sourceLayerID, + const std::string& featureID, + const FeatureState& state) { + impl->orchestrator.setFeatureState(sourceID, sourceLayerID, featureID, state); +} + +void Renderer::getFeatureState(FeatureState& state, + const std::string& sourceID, + const optional& sourceLayerID, + const std::string& featureID) const { + impl->orchestrator.getFeatureState(state, sourceID, sourceLayerID, featureID); +} + void Renderer::dumpDebugLogs() { impl->orchestrator.dumpDebugLogs(); } diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index c5afb38435..6859c454f3 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -68,6 +68,7 @@ void RenderTileSource::prepare(const SourcePrepareParameters& parameters) { tiles->emplace_back(entry.first, entry.second); tiles->back().prepare(parameters); } + featureState.coalesceChanges(*tiles); renderTiles = std::move(tiles); } @@ -133,6 +134,18 @@ std::vector RenderTileSource::querySourceFeatures(const SourceQueryOpti return tilePyramid.querySourceFeatures(options); } +void RenderTileSource::setFeatureState(const optional& sourceLayerID, + const std::string& featureID, + const FeatureState& state) { + featureState.updateState(sourceLayerID, featureID, state); +} + +void RenderTileSource::getFeatureState(FeatureState& state, + const optional& sourceLayerID, + const std::string& featureID) const { + featureState.getState(state, sourceLayerID, featureID); +} + void RenderTileSource::reduceMemoryUse() { tilePyramid.reduceMemoryUse(); } diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp index 7edff726d5..822b2cac16 100644 --- a/src/mbgl/renderer/sources/render_tile_source.hpp +++ b/src/mbgl/renderer/sources/render_tile_source.hpp @@ -3,6 +3,7 @@ #include #include #include +#include namespace mbgl { @@ -34,6 +35,14 @@ public: std::vector querySourceFeatures(const SourceQueryOptions&) const override; + virtual void setFeatureState(const optional&, + const std::string&, + const FeatureState&) override; + + virtual void getFeatureState(FeatureState& state, + const optional&, + const std::string&) const override; + void reduceMemoryUse() override; void dumpDebugLogs() const override; @@ -44,6 +53,7 @@ protected: mutable RenderTiles filteredRenderTiles; mutable RenderTiles renderTilesSortedByY; float bearing = 0.0f; + SourceFeatureState featureState; }; /** -- cgit v1.2.1 From 598df1897dcad6f0a003fbae5d9058b1a660f408 Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 15:40:11 +0300 Subject: [core] Add feature state support to queryRenderedFeatures API --- src/mbgl/annotation/render_annotation_source.cpp | 2 +- src/mbgl/geometry/feature_index.cpp | 24 +++++++++++++++++++----- src/mbgl/geometry/feature_index.hpp | 7 +++++-- src/mbgl/renderer/sources/render_tile_source.cpp | 2 +- src/mbgl/renderer/tile_pyramid.cpp | 6 ++++-- src/mbgl/renderer/tile_pyramid.hpp | 3 ++- src/mbgl/tile/geometry_tile.cpp | 6 ++++-- src/mbgl/tile/geometry_tile.hpp | 3 ++- src/mbgl/tile/tile.cpp | 3 ++- src/mbgl/tile/tile.hpp | 4 +++- 10 files changed, 43 insertions(+), 17 deletions(-) (limited to 'src') diff --git a/src/mbgl/annotation/render_annotation_source.cpp b/src/mbgl/annotation/render_annotation_source.cpp index 903825d5f5..e3acfcb3c0 100644 --- a/src/mbgl/annotation/render_annotation_source.cpp +++ b/src/mbgl/annotation/render_annotation_source.cpp @@ -49,7 +49,7 @@ RenderAnnotationSource::queryRenderedFeatures(const ScreenLineString& geometry, const std::unordered_map& layers, const RenderedQueryOptions& options, const mat4& projMatrix) const { - return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix); + return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix, {}); } std::vector RenderAnnotationSource::querySourceFeatures(const SourceQueryOptions&) const { diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp index b76e02be3f..2601d60979 100644 --- a/src/mbgl/geometry/feature_index.cpp +++ b/src/mbgl/geometry/feature_index.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include @@ -48,7 +49,8 @@ void FeatureIndex::query( const RenderedQueryOptions& queryOptions, const UnwrappedTileID& tileID, const std::unordered_map& layers, - const float additionalQueryPadding) const { + const float additionalQueryPadding, + const SourceFeatureState& sourceFeatureState) const { if (!tileData) { return; @@ -74,7 +76,7 @@ void FeatureIndex::query( if (indexedFeature.sortIndex == previousSortIndex) continue; previousSortIndex = indexedFeature.sortIndex; - addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState, pixelsToTileUnits, posMatrix); + addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState, pixelsToTileUnits, posMatrix, &sourceFeatureState); } } @@ -113,7 +115,7 @@ FeatureIndex::lookupSymbolFeatures(const std::vector& symbolF for (const auto& symbolFeature : sortedFeatures) { mat4 unusedMatrix; - addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, unusedMatrix); + addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, unusedMatrix, nullptr); } return result; } @@ -127,7 +129,8 @@ void FeatureIndex::addFeature( const GeometryCoordinates& queryGeometry, const TransformState& transformState, const float pixelsToTileUnits, - const mat4& posMatrix) const { + const mat4& posMatrix, + const SourceFeatureState* sourceFeatureState) const { // Lazily calculated. std::unique_ptr sourceLayer; @@ -148,6 +151,13 @@ void FeatureIndex::addFeature( geometryTileFeature = sourceLayer->getFeature(indexedFeature.index); assert(geometryTileFeature); } + FeatureState state; + if (sourceFeatureState) { + optional idStr = featureIDtoString(geometryTileFeature->getID()); + if (idStr) { + sourceFeatureState->getState(state, sourceLayer->getName(), *idStr); + } + } bool needsCrossTileIndex = renderLayer->baseImpl->getTypeInfo()->crossTileIndex == style::LayerTypeInfo::CrossTileIndex::Required; if (!needsCrossTileIndex && @@ -159,7 +169,11 @@ void FeatureIndex::addFeature( continue; } - result[layerID].emplace_back(convertFeature(*geometryTileFeature, tileID)); + Feature feature = convertFeature(*geometryTileFeature, tileID); + feature.source = renderLayer->baseImpl->source; + feature.sourceLayer = sourceLayer->getName(); + feature.state = state; + result[layerID].emplace_back(feature); } } diff --git a/src/mbgl/geometry/feature_index.hpp b/src/mbgl/geometry/feature_index.hpp index 1a212761fa..ab0cfea7db 100644 --- a/src/mbgl/geometry/feature_index.hpp +++ b/src/mbgl/geometry/feature_index.hpp @@ -16,6 +16,7 @@ namespace mbgl { class RenderedQueryOptions; class RenderLayer; class TransformState; +class SourceFeatureState; class CollisionIndex; @@ -68,7 +69,8 @@ public: const RenderedQueryOptions& options, const UnwrappedTileID&, const std::unordered_map&, - const float additionalQueryPadding) const; + const float additionalQueryPadding, + const SourceFeatureState& sourceFeatureState) const; static optional translateQueryGeometry( const GeometryCoordinates& queryGeometry, @@ -96,7 +98,8 @@ private: const GeometryCoordinates& queryGeometry, const TransformState& transformState, const float pixelsToTileUnits, - const mat4& posMatrix) const; + const mat4& posMatrix, + const SourceFeatureState* sourceFeatureState) const; GridIndex grid; unsigned int sortIndex = 0; diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index 6859c454f3..f2297f7ed4 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -127,7 +127,7 @@ RenderTileSource::queryRenderedFeatures(const ScreenLineString& geometry, const std::unordered_map& layers, const RenderedQueryOptions& options, const mat4& projMatrix) const { - return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix); + return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix, featureState); } std::vector RenderTileSource::querySourceFeatures(const SourceQueryOptions& options) const { diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp index 7f0fad1500..db3e731605 100644 --- a/src/mbgl/renderer/tile_pyramid.cpp +++ b/src/mbgl/renderer/tile_pyramid.cpp @@ -283,7 +283,8 @@ std::unordered_map> TilePyramid::queryRendered const TransformState& transformState, const std::unordered_map& layers, const RenderedQueryOptions& options, - const mat4& projMatrix) const { + const mat4& projMatrix, + const SourceFeatureState& featureState) const { std::unordered_map> result; if (renderedTiles.empty() || geometry.empty()) { return result; @@ -336,7 +337,8 @@ std::unordered_map> TilePyramid::queryRendered transformState, layers, options, - projMatrix); + projMatrix, + featureState); } return result; diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp index f80eb0db78..bb0b7e9f67 100644 --- a/src/mbgl/renderer/tile_pyramid.hpp +++ b/src/mbgl/renderer/tile_pyramid.hpp @@ -54,7 +54,8 @@ public: const TransformState& transformState, const std::unordered_map&, const RenderedQueryOptions& options, - const mat4& projMatrix) const; + const mat4& projMatrix, + const mbgl::SourceFeatureState& featureState) const; std::vector querySourceFeatures(const SourceQueryOptions&) const; diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp index 8f624f21dc..2076c73337 100644 --- a/src/mbgl/tile/geometry_tile.cpp +++ b/src/mbgl/tile/geometry_tile.cpp @@ -308,7 +308,8 @@ void GeometryTile::queryRenderedFeatures( const TransformState& transformState, const std::unordered_map& layers, const RenderedQueryOptions& options, - const mat4& projMatrix) { + const mat4& projMatrix, + const SourceFeatureState& featureState) { if (!getData()) return; @@ -327,7 +328,8 @@ void GeometryTile::queryRenderedFeatures( options, id.toUnwrapped(), layers, - queryPadding * transformState.maxPitchScaleFactor()); + queryPadding * transformState.maxPitchScaleFactor(), + featureState); } void GeometryTile::querySourceFeatures( diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp index ca9e33218c..4415e0a1fa 100644 --- a/src/mbgl/tile/geometry_tile.hpp +++ b/src/mbgl/tile/geometry_tile.hpp @@ -54,7 +54,8 @@ public: const TransformState&, const std::unordered_map& layers, const RenderedQueryOptions& options, - const mat4& projMatrix) override; + const mat4& projMatrix, + const SourceFeatureState& featureState) override; void querySourceFeatures( std::vector& result, diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp index 2f342c092d..87223c7933 100644 --- a/src/mbgl/tile/tile.cpp +++ b/src/mbgl/tile/tile.cpp @@ -45,7 +45,8 @@ void Tile::queryRenderedFeatures( const TransformState&, const std::unordered_map&, const RenderedQueryOptions&, - const mat4&) {} + const mat4&, + const SourceFeatureState&) {} float Tile::getQueryPadding(const std::unordered_map&) { return 0; diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp index 65bff305a3..eda4667027 100644 --- a/src/mbgl/tile/tile.hpp +++ b/src/mbgl/tile/tile.hpp @@ -28,6 +28,7 @@ class TileRenderData; class RenderedQueryOptions; class SourceQueryOptions; class CollisionIndex; +class SourceFeatureState; namespace gfx { class UploadPass; @@ -73,7 +74,8 @@ public: const TransformState&, const std::unordered_map&, const RenderedQueryOptions& options, - const mat4& projMatrix); + const mat4& projMatrix, + const SourceFeatureState& featureState); virtual void querySourceFeatures( std::vector& result, -- cgit v1.2.1 From 7ce9b0d47d794411bdf1315e22b6b8234c4f1a9d Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Wed, 21 Aug 2019 16:12:25 +0300 Subject: [core] Feature state support to RenderLayer classes --- src/mbgl/geometry/feature_index.cpp | 2 +- src/mbgl/renderer/layers/render_circle_layer.cpp | 7 ++++--- src/mbgl/renderer/layers/render_circle_layer.hpp | 3 ++- src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp | 3 ++- src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp | 3 ++- src/mbgl/renderer/layers/render_fill_layer.cpp | 3 ++- src/mbgl/renderer/layers/render_fill_layer.hpp | 3 ++- src/mbgl/renderer/layers/render_heatmap_layer.cpp | 3 ++- src/mbgl/renderer/layers/render_heatmap_layer.hpp | 3 ++- src/mbgl/renderer/layers/render_line_layer.cpp | 13 +++++++------ src/mbgl/renderer/layers/render_line_layer.hpp | 5 +++-- src/mbgl/renderer/render_layer.hpp | 3 ++- 12 files changed, 31 insertions(+), 20 deletions(-) (limited to 'src') diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp index 2601d60979..571ff172f8 100644 --- a/src/mbgl/geometry/feature_index.cpp +++ b/src/mbgl/geometry/feature_index.cpp @@ -161,7 +161,7 @@ void FeatureIndex::addFeature( bool needsCrossTileIndex = renderLayer->baseImpl->getTypeInfo()->crossTileIndex == style::LayerTypeInfo::CrossTileIndex::Required; if (!needsCrossTileIndex && - !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState, pixelsToTileUnits, posMatrix)) { + !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState, pixelsToTileUnits, posMatrix, state)) { continue; } diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index ea0c20f124..76dadd80bf 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -147,7 +147,8 @@ bool RenderCircleLayer::queryIntersectsFeature( const float zoom, const TransformState& transformState, const float pixelsToTileUnits, - const mat4& posMatrix) const { + const mat4& posMatrix, + const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; // Translate query geometry const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry( @@ -158,8 +159,8 @@ bool RenderCircleLayer::queryIntersectsFeature( pixelsToTileUnits).value_or(queryGeometry); // Evaluate functions - auto radius = evaluated.evaluate(zoom, feature); - auto stroke = evaluated.evaluate(zoom, feature); + auto radius = evaluated.evaluate(zoom, feature, featureState); + auto stroke = evaluated.evaluate(zoom, feature, featureState); auto size = radius + stroke; // For pitch-alignment: map, compare feature geometry to query geometry in the plane of the tile diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp index 9348e48929..ee0318da7c 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.hpp +++ b/src/mbgl/renderer/layers/render_circle_layer.hpp @@ -24,7 +24,8 @@ private: const float, const TransformState&, const float, - const mat4&) const override; + const mat4&, + const FeatureState&) const override; // Paint properties style::CirclePaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp index 835e8c8ee5..b6ffa3f8f9 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp @@ -230,7 +230,8 @@ bool RenderFillExtrusionLayer::queryIntersectsFeature( const float, const TransformState& transformState, const float pixelsToTileUnits, - const mat4&) const { + const mat4&, + const FeatureState&) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( queryGeometry, diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp index 8bd1f52adf..bad2c26122 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp @@ -26,7 +26,8 @@ private: const float, const TransformState&, const float, - const mat4&) const override; + const mat4&, + const FeatureState&) const override; // Paint properties style::FillExtrusionPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 27cb76fede..40b3c289f2 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -255,7 +255,8 @@ bool RenderFillLayer::queryIntersectsFeature( const float, const TransformState& transformState, const float pixelsToTileUnits, - const mat4&) const { + const mat4&, + const FeatureState&) const { const auto& evaluated = getEvaluated(evaluatedProperties); auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( queryGeometry, diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp index 79adc9dab4..182e0c544c 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.hpp +++ b/src/mbgl/renderer/layers/render_fill_layer.hpp @@ -27,7 +27,8 @@ private: const float, const TransformState&, const float, - const mat4&) const override; + const mat4&, + const FeatureState&) const override; // Paint properties style::FillPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 4fa20ffd13..777269f9db 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -225,7 +225,8 @@ bool RenderHeatmapLayer::queryIntersectsFeature( const float zoom, const TransformState&, const float pixelsToTileUnits, - const mat4&) const { + const mat4&, + const FeatureState&) const { (void) queryGeometry; (void) feature; (void) zoom; diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp index 27e27adb28..1c1eb67ad5 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp @@ -28,7 +28,8 @@ private: const float, const TransformState&, const float, - const mat4&) const override; + const mat4&, + const FeatureState&) const override; // Paint properties style::HeatmapPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index 6d635f65e7..fe3ca00f06 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -263,7 +263,8 @@ bool RenderLineLayer::queryIntersectsFeature( const float zoom, const TransformState& transformState, const float pixelsToTileUnits, - const mat4&) const { + const mat4&, + const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; // Translate query geometry auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( @@ -275,9 +276,9 @@ bool RenderLineLayer::queryIntersectsFeature( // Evaluate function auto offset = evaluated.get() - .evaluate(feature, zoom, style::LineOffset::defaultValue()) * pixelsToTileUnits; + .evaluate(feature, zoom, featureState, style::LineOffset::defaultValue()) * pixelsToTileUnits; // Test intersection - const float halfWidth = getLineWidth(feature, zoom) / 2.0 * pixelsToTileUnits; + const float halfWidth = getLineWidth(feature, zoom, featureState) / 2.0 * pixelsToTileUnits; // Apply offset to geometry if (offset != 0.0f && !feature.getGeometries().empty()) { @@ -314,12 +315,12 @@ void RenderLineLayer::updateColorRamp() { } } -float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const { +float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom, const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; float lineWidth = evaluated.get() - .evaluate(feature, zoom, style::LineWidth::defaultValue()); + .evaluate(feature, zoom, featureState, style::LineWidth::defaultValue()); float gapWidth = evaluated.get() - .evaluate(feature, zoom, style::LineGapWidth::defaultValue()); + .evaluate(feature, zoom, featureState, style::LineGapWidth::defaultValue()); if (gapWidth) { return gapWidth + 2 * lineWidth; } else { diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp index 4454d215d9..d4d84eb34e 100644 --- a/src/mbgl/renderer/layers/render_line_layer.hpp +++ b/src/mbgl/renderer/layers/render_line_layer.hpp @@ -30,12 +30,13 @@ private: const float, const TransformState&, const float, - const mat4&) const override; + const mat4&, + const FeatureState&) const override; // Paint properties style::LinePaintProperties::Unevaluated unevaluated; - float getLineWidth(const GeometryTileFeature&, const float) const; + float getLineWidth(const GeometryTileFeature&, const float, const FeatureState&) const; void updateColorRamp(); PremultipliedImage colorRamp; diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp index 75c729444b..2b65d069ae 100644 --- a/src/mbgl/renderer/render_layer.hpp +++ b/src/mbgl/renderer/render_layer.hpp @@ -94,7 +94,8 @@ public: const float, const TransformState&, const float, - const mat4&) const { return false; }; + const mat4&, + const FeatureState&) const { return false; }; virtual void prepare(const LayerPrepareParameters&); -- cgit v1.2.1 From 48f462bc7b09285c09c2a6f3cd07b555fcd21f43 Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Fri, 13 Sep 2019 11:15:21 +0300 Subject: [core] Add removeFeatureState API --- src/mbgl/renderer/render_orchestrator.cpp | 9 ++++ src/mbgl/renderer/render_orchestrator.hpp | 5 +++ src/mbgl/renderer/render_source.hpp | 4 ++ src/mbgl/renderer/renderer.cpp | 7 +++ src/mbgl/renderer/source_state.cpp | 54 ++++++++++++++++++++++++ src/mbgl/renderer/source_state.hpp | 2 + src/mbgl/renderer/sources/render_tile_source.cpp | 6 +++ src/mbgl/renderer/sources/render_tile_source.hpp | 4 ++ 8 files changed, 91 insertions(+) (limited to 'src') diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp index fbf98500b4..6bccee7798 100644 --- a/src/mbgl/renderer/render_orchestrator.cpp +++ b/src/mbgl/renderer/render_orchestrator.cpp @@ -580,6 +580,15 @@ void RenderOrchestrator::getFeatureState(FeatureState& state, } } +void RenderOrchestrator::removeFeatureState(const std::string& sourceID, + const optional& sourceLayerID, + const optional& featureID, + const optional& stateKey) { + if (RenderSource* renderSource = getRenderSource(sourceID)) { + renderSource->removeFeatureState(sourceLayerID, featureID, stateKey); + } +} + void RenderOrchestrator::reduceMemoryUse() { filteredLayersForSource.shrink_to_fit(); for (const auto& entry : renderSources) { diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp index 7467e0c7dd..f42a40ec33 100644 --- a/src/mbgl/renderer/render_orchestrator.hpp +++ b/src/mbgl/renderer/render_orchestrator.hpp @@ -74,6 +74,11 @@ public: const optional& layerID, const std::string& featureID) const; + void removeFeatureState(const std::string& sourceID, + const optional& sourceLayerID, + const optional& featureID, + const optional& stateKey); + void reduceMemoryUse(); void dumpDebugLogs(); diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp index c803c82c95..39ca97d563 100644 --- a/src/mbgl/renderer/render_source.hpp +++ b/src/mbgl/renderer/render_source.hpp @@ -101,6 +101,10 @@ public: const optional&, const std::string&) const {} + virtual void removeFeatureState(const optional&, + const optional&, + const optional&) {} + virtual void reduceMemoryUse() = 0; virtual void dumpDebugLogs() const = 0; diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp index 40b342b1d4..a91a0098ca 100644 --- a/src/mbgl/renderer/renderer.cpp +++ b/src/mbgl/renderer/renderer.cpp @@ -123,6 +123,13 @@ void Renderer::getFeatureState(FeatureState& state, impl->orchestrator.getFeatureState(state, sourceID, sourceLayerID, featureID); } +void Renderer::removeFeatureState(const std::string& sourceID, + const optional& sourceLayerID, + const optional& featureID, + const optional& stateKey) { + impl->orchestrator.removeFeatureState(sourceID, sourceLayerID, featureID, stateKey); +} + void Renderer::dumpDebugLogs() { impl->orchestrator.dumpDebugLogs(); } diff --git a/src/mbgl/renderer/source_state.cpp b/src/mbgl/renderer/source_state.cpp index 087e28b2bb..c1b95aca68 100644 --- a/src/mbgl/renderer/source_state.cpp +++ b/src/mbgl/renderer/source_state.cpp @@ -58,7 +58,37 @@ void SourceFeatureState::coalesceChanges(std::vector& tiles) { } changes[sourceLayer] = std::move(layerStates); } + + for (const auto& layerStatesEntry : deletedStates) { + const auto& sourceLayer = layerStatesEntry.first; + FeatureStates layerStates = { {}, {} }; + + if (deletedStates[sourceLayer].empty()) { + for (const auto& featureStatesEntry : currentStates[sourceLayer]) { + const auto& featureID = featureStatesEntry.first; + layerStates[featureID] = {}; + currentStates[sourceLayer][featureID] = {}; + } + } else { + for (const auto& feature : deletedStates[sourceLayer]) { + const auto& featureID = feature.first; + bool deleteWholeFeatureState = deletedStates[sourceLayer][featureID].empty(); + if (deleteWholeFeatureState) { + currentStates[sourceLayer][featureID] = {}; + } else { + for (const auto& stateEntry : deletedStates[sourceLayer][featureID]) { + currentStates[sourceLayer][featureID].erase(stateEntry.first); + } + } + layerStates[featureID] = currentStates[sourceLayer][featureID]; + } + } + changes[sourceLayer] = std::move(layerStates); + } + stateChanges.clear(); + deletedStates.clear(); + if (changes.empty()) return; for (auto& tile : tiles) { @@ -66,4 +96,28 @@ void SourceFeatureState::coalesceChanges(std::vector& tiles) { } } +void SourceFeatureState::removeState(const optional& sourceLayerID, const optional& featureID, const optional& stateKey) { + std::string sourceLayer = sourceLayerID.value_or(std::string()); + + bool sourceLayerDeleted = (deletedStates.count(sourceLayer) > 0) && deletedStates[sourceLayer].empty(); + if (sourceLayerDeleted) return; + + if (stateKey && featureID) { + if ((deletedStates.count(sourceLayer) == 0) && (deletedStates[sourceLayer].count(*featureID)) == 0) { + deletedStates[sourceLayer][*featureID][*stateKey] = {}; + } + } else if (featureID) { + bool updateInQueue = stateChanges.count(sourceLayer) && stateChanges[sourceLayer].count(*featureID); + if (updateInQueue) { + for (const auto& changeEntry : stateChanges[sourceLayer][*featureID]) { + deletedStates[sourceLayer][*featureID][changeEntry.first] = {}; + } + } else { + deletedStates[sourceLayer][*featureID] = {}; + } + } else { + deletedStates[sourceLayer] = {}; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/source_state.hpp b/src/mbgl/renderer/source_state.hpp index 9944709b0d..61546aff62 100644 --- a/src/mbgl/renderer/source_state.hpp +++ b/src/mbgl/renderer/source_state.hpp @@ -15,12 +15,14 @@ public: void updateState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& newState); void getState(FeatureState& result, const optional& sourceLayerID, const std::string& featureID) const; + void removeState(const optional& sourceLayerID, const optional& featureID, const optional& stateKey); void coalesceChanges(std::vector& tiles); private: LayerFeatureStates currentStates; LayerFeatureStates stateChanges; + LayerFeatureStates deletedStates; }; } // namespace mbgl diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index f2297f7ed4..3c6eff0855 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -146,6 +146,12 @@ void RenderTileSource::getFeatureState(FeatureState& state, featureState.getState(state, sourceLayerID, featureID); } +void RenderTileSource::removeFeatureState(const optional& sourceLayerID, + const optional& featureID, + const optional& stateKey) { + featureState.removeState(sourceLayerID, featureID, stateKey); +} + void RenderTileSource::reduceMemoryUse() { tilePyramid.reduceMemoryUse(); } diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp index 822b2cac16..48eea8558c 100644 --- a/src/mbgl/renderer/sources/render_tile_source.hpp +++ b/src/mbgl/renderer/sources/render_tile_source.hpp @@ -43,6 +43,10 @@ public: const optional&, const std::string&) const override; + virtual void removeFeatureState(const optional&, + const optional&, + const optional&) override; + void reduceMemoryUse() override; void dumpDebugLogs() const override; -- cgit v1.2.1 From 6b13c42314f28e3b27111367c4f3296c3c3c1248 Mon Sep 17 00:00:00 2001 From: Juha Alanen Date: Tue, 17 Sep 2019 15:40:01 +0300 Subject: [build] Fix clang format and tidy checks --- src/mbgl/geometry/feature_index.cpp | 63 ++++---- src/mbgl/geometry/feature_index.hpp | 34 ++-- src/mbgl/layout/symbol_layout.cpp | 6 +- src/mbgl/renderer/bucket.hpp | 8 +- src/mbgl/renderer/buckets/circle_bucket.cpp | 10 +- src/mbgl/renderer/buckets/circle_bucket.hpp | 7 +- src/mbgl/renderer/buckets/fill_bucket.cpp | 12 +- src/mbgl/renderer/buckets/fill_bucket.hpp | 7 +- .../renderer/buckets/fill_extrusion_bucket.cpp | 9 +- .../renderer/buckets/fill_extrusion_bucket.hpp | 7 +- src/mbgl/renderer/buckets/heatmap_bucket.cpp | 7 +- src/mbgl/renderer/buckets/heatmap_bucket.hpp | 7 +- src/mbgl/renderer/buckets/line_bucket.cpp | 10 +- src/mbgl/renderer/buckets/line_bucket.hpp | 7 +- src/mbgl/renderer/layers/render_circle_layer.cpp | 12 +- src/mbgl/renderer/layers/render_circle_layer.hpp | 10 +- .../layers/render_fill_extrusion_layer.cpp | 13 +- .../layers/render_fill_extrusion_layer.hpp | 10 +- src/mbgl/renderer/layers/render_fill_layer.cpp | 13 +- src/mbgl/renderer/layers/render_fill_layer.hpp | 10 +- src/mbgl/renderer/layers/render_heatmap_layer.cpp | 12 +- src/mbgl/renderer/layers/render_heatmap_layer.hpp | 10 +- src/mbgl/renderer/layers/render_line_layer.cpp | 30 ++-- src/mbgl/renderer/layers/render_line_layer.hpp | 10 +- src/mbgl/renderer/paint_property_binder.hpp | 76 +++++---- .../renderer/possibly_evaluated_property_value.hpp | 10 +- src/mbgl/renderer/render_layer.hpp | 12 +- src/mbgl/renderer/render_orchestrator.cpp | 12 +- src/mbgl/renderer/render_orchestrator.hpp | 18 +-- src/mbgl/renderer/render_source.hpp | 11 +- src/mbgl/renderer/renderer.cpp | 18 +-- src/mbgl/renderer/source_state.cpp | 27 ++-- src/mbgl/renderer/source_state.hpp | 7 +- src/mbgl/renderer/sources/render_tile_source.cpp | 6 +- src/mbgl/renderer/sources/render_tile_source.hpp | 19 +-- src/mbgl/renderer/tile_pyramid.cpp | 18 +-- src/mbgl/renderer/tile_pyramid.hpp | 11 +- src/mbgl/style/expression/compound_expression.cpp | 172 +++++++++++---------- src/mbgl/style/expression/is_constant.cpp | 7 +- src/mbgl/style/properties.hpp | 9 +- src/mbgl/tile/geometry_tile.cpp | 41 +++-- src/mbgl/tile/geometry_tile.hpp | 15 +- src/mbgl/tile/geometry_tile_worker.cpp | 2 +- src/mbgl/tile/tile.cpp | 11 +- src/mbgl/tile/tile.hpp | 13 +- 45 files changed, 348 insertions(+), 491 deletions(-) (limited to 'src') diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp index 571ff172f8..20026dd117 100644 --- a/src/mbgl/geometry/feature_index.cpp +++ b/src/mbgl/geometry/feature_index.cpp @@ -1,14 +1,14 @@ #include -#include -#include +#include #include +#include +#include +#include +#include #include +#include #include #include -#include -#include -#include -#include #include @@ -39,19 +39,12 @@ void FeatureIndex::insert(const GeometryCollection& geometries, } } -void FeatureIndex::query( - std::unordered_map>& result, - const GeometryCoordinates& queryGeometry, - const TransformState& transformState, - const mat4& posMatrix, - const double tileSize, - const double scale, - const RenderedQueryOptions& queryOptions, - const UnwrappedTileID& tileID, - const std::unordered_map& layers, - const float additionalQueryPadding, - const SourceFeatureState& sourceFeatureState) const { - +void FeatureIndex::query(std::unordered_map>& result, + const GeometryCoordinates& queryGeometry, const TransformState& transformState, + const mat4& posMatrix, const double tileSize, const double scale, + const RenderedQueryOptions& queryOptions, const UnwrappedTileID& tileID, + const std::unordered_map& layers, + const float additionalQueryPadding, const SourceFeatureState& sourceFeatureState) const { if (!tileData) { return; } @@ -76,10 +69,11 @@ void FeatureIndex::query( if (indexedFeature.sortIndex == previousSortIndex) continue; previousSortIndex = indexedFeature.sortIndex; - addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState, pixelsToTileUnits, posMatrix, &sourceFeatureState); + addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState, + pixelsToTileUnits, posMatrix, &sourceFeatureState); } } - + std::unordered_map> FeatureIndex::lookupSymbolFeatures(const std::vector& symbolFeatures, const RenderedQueryOptions& queryOptions, @@ -115,23 +109,19 @@ FeatureIndex::lookupSymbolFeatures(const std::vector& symbolF for (const auto& symbolFeature : sortedFeatures) { mat4 unusedMatrix; - addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, unusedMatrix, nullptr); + addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, + unusedMatrix, nullptr); } return result; } -void FeatureIndex::addFeature( - std::unordered_map>& result, - const IndexedSubfeature& indexedFeature, - const RenderedQueryOptions& options, - const CanonicalTileID& tileID, - const std::unordered_map& layers, - const GeometryCoordinates& queryGeometry, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4& posMatrix, - const SourceFeatureState* sourceFeatureState) const { - +void FeatureIndex::addFeature(std::unordered_map>& result, + const IndexedSubfeature& indexedFeature, const RenderedQueryOptions& options, + const CanonicalTileID& tileID, + const std::unordered_map& layers, + const GeometryCoordinates& queryGeometry, const TransformState& transformState, + const float pixelsToTileUnits, const mat4& posMatrix, + const SourceFeatureState* sourceFeatureState) const { // Lazily calculated. std::unique_ptr sourceLayer; std::unique_ptr geometryTileFeature; @@ -152,7 +142,7 @@ void FeatureIndex::addFeature( assert(geometryTileFeature); } FeatureState state; - if (sourceFeatureState) { + if (sourceFeatureState != nullptr) { optional idStr = featureIDtoString(geometryTileFeature->getID()); if (idStr) { sourceFeatureState->getState(state, sourceLayer->getName(), *idStr); @@ -161,7 +151,8 @@ void FeatureIndex::addFeature( bool needsCrossTileIndex = renderLayer->baseImpl->getTypeInfo()->crossTileIndex == style::LayerTypeInfo::CrossTileIndex::Required; if (!needsCrossTileIndex && - !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState, pixelsToTileUnits, posMatrix, state)) { + !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState, + pixelsToTileUnits, posMatrix, state)) { continue; } diff --git a/src/mbgl/geometry/feature_index.hpp b/src/mbgl/geometry/feature_index.hpp index ab0cfea7db..5a006a51bc 100644 --- a/src/mbgl/geometry/feature_index.hpp +++ b/src/mbgl/geometry/feature_index.hpp @@ -59,18 +59,11 @@ public: void insert(const GeometryCollection&, std::size_t index, const std::string& sourceLayerName, const std::string& bucketLeaderID); - void query( - std::unordered_map>& result, - const GeometryCoordinates& queryGeometry, - const TransformState&, - const mat4& posMatrix, - const double tileSize, - const double scale, - const RenderedQueryOptions& options, - const UnwrappedTileID&, - const std::unordered_map&, - const float additionalQueryPadding, - const SourceFeatureState& sourceFeatureState) const; + void query(std::unordered_map>& result, const GeometryCoordinates& queryGeometry, + const TransformState&, const mat4& posMatrix, const double tileSize, const double scale, + const RenderedQueryOptions& options, const UnwrappedTileID&, + const std::unordered_map&, const float additionalQueryPadding, + const SourceFeatureState& sourceFeatureState) const; static optional translateQueryGeometry( const GeometryCoordinates& queryGeometry, @@ -89,17 +82,12 @@ public: const std::shared_ptr>& featureSortOrder) const; private: - void addFeature( - std::unordered_map>& result, - const IndexedSubfeature&, - const RenderedQueryOptions& options, - const CanonicalTileID&, - const std::unordered_map&, - const GeometryCoordinates& queryGeometry, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4& posMatrix, - const SourceFeatureState* sourceFeatureState) const; + void addFeature(std::unordered_map>& result, const IndexedSubfeature&, + const RenderedQueryOptions& options, const CanonicalTileID&, + const std::unordered_map&, + const GeometryCoordinates& queryGeometry, const TransformState& transformState, + const float pixelsToTileUnits, const mat4& posMatrix, + const SourceFeatureState* sourceFeatureState) const; GridIndex grid; unsigned int sortIndex = 0; diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp index 71724cad5f..81d1d9a5b6 100644 --- a/src/mbgl/layout/symbol_layout.cpp +++ b/src/mbgl/layout/symbol_layout.cpp @@ -713,7 +713,8 @@ void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptrpaintProperties) { - pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(), symbolInstance.dataFeatureIndex, {}, {}); + pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(), + symbolInstance.dataFeatureIndex, {}, {}); } } @@ -765,7 +766,8 @@ void SymbolLayout::updatePaintPropertiesForSection(SymbolBucket& bucket, std::size_t sectionIndex) { const auto& formattedSection = sectionOptionsToValue((*feature.formattedText).sectionAt(sectionIndex)); for (auto& pair : bucket.paintProperties) { - pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), feature.index, {}, {}, formattedSection); + pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), feature.index, {}, {}, + formattedSection); } } diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 98c2200ce9..6c74b8309f 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -32,15 +32,11 @@ public: // Feature geometries are also used to populate the feature index. // Obtaining these is a costly operation, so we do it only once, and // pass-by-const-ref the geometries as a second parameter. - virtual void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const ImagePositions&, - const PatternLayerMap&, - std::size_t) {}; + virtual void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, + const PatternLayerMap&, std::size_t){}; virtual void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) {} - // 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(gfx::UploadPass&) = 0; diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp index ffa6f59128..560a74781a 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.cpp +++ b/src/mbgl/renderer/buckets/circle_bucket.cpp @@ -41,11 +41,8 @@ bool CircleBucket::hasData() const { return !segments.empty(); } -void CircleBucket::addFeature(const GeometryTileFeature& feature, - const GeometryCollection& geometry, - const ImagePositions&, - const PatternLayerMap&, - std::size_t featureIndex) { +void CircleBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, + const ImagePositions&, const PatternLayerMap&, std::size_t featureIndex) { constexpr const uint16_t vertexLength = 4; for (auto& circle : geometry) { @@ -115,7 +112,8 @@ float CircleBucket::getQueryRadius(const RenderLayer& layer) const { return radius + stroke + util::length(translate[0], translate[1]); } -void CircleBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { +void CircleBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, + const ImagePositions& imagePositions) { auto it = paintPropertyBinders.find(layerID); if (it != paintPropertyBinders.end()) { it->second.updateVertexVectors(states, layer, imagePositions); diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp index 9fee45ad79..e514f8a5f2 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.hpp +++ b/src/mbgl/renderer/buckets/circle_bucket.hpp @@ -18,11 +18,8 @@ public: CircleBucket(const BucketParameters&, const std::vector>&); ~CircleBucket() override; - void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const ImagePositions&, - const PatternLayerMap&, - std::size_t) override; + void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, + const PatternLayerMap&, std::size_t) override; bool hasData() const override; diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp index ea79a1e687..6660934f8d 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_bucket.cpp @@ -44,10 +44,8 @@ FillBucket::FillBucket(const FillBucket::PossiblyEvaluatedLayoutProperties, FillBucket::~FillBucket() = default; -void FillBucket::addFeature(const GeometryTileFeature& feature, - const GeometryCollection& geometry, - const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies, +void FillBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, + const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies, std::size_t index) { for (auto& polygon : classifyRings(geometry)) { // Optimize polygons with many interior rings for earcut tesselation. @@ -126,7 +124,8 @@ void FillBucket::upload(gfx::UploadPass& uploadPass) { if (!uploaded) { vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); lineIndexBuffer = uploadPass.createIndexBuffer(std::move(lines)); - triangleIndexBuffer = triangles.empty() ? optional {} : uploadPass.createIndexBuffer(std::move(triangles)); + triangleIndexBuffer = + triangles.empty() ? optional{} : uploadPass.createIndexBuffer(std::move(triangles)); } for (auto& pair : paintPropertyBinders) { @@ -146,7 +145,8 @@ float FillBucket::getQueryRadius(const RenderLayer& layer) const { return util::length(translate[0], translate[1]); } -void FillBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { +void FillBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, + const ImagePositions& imagePositions) { auto it = paintPropertyBinders.find(layerID); if (it != paintPropertyBinders.end()) { it->second.updateVertexVectors(states, layer, imagePositions); diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp index eee421f938..9f65e774ca 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_bucket.hpp @@ -26,11 +26,8 @@ public: const float zoom, const uint32_t overscaling); - void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const mbgl::ImagePositions&, - const PatternLayerMap&, - std::size_t) override; + void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&, + const PatternLayerMap&, std::size_t) override; bool hasData() const override; diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp index 6a25349c22..698895fdcf 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp @@ -50,10 +50,8 @@ FillExtrusionBucket::FillExtrusionBucket(const FillExtrusionBucket::PossiblyEval FillExtrusionBucket::~FillExtrusionBucket() = default; -void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, - const GeometryCollection& geometry, - const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies, +void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, + const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies, std::size_t index) { for (auto& polygon : classifyRings(geometry)) { // Optimize polygons with many interior rings for earcut tesselation. @@ -189,7 +187,8 @@ float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const { return util::length(translate[0], translate[1]); } -void FillExtrusionBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { +void FillExtrusionBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, + const std::string& layerID, const ImagePositions& imagePositions) { auto it = paintPropertyBinders.find(layerID); if (it != paintPropertyBinders.end()) { it->second.updateVertexVectors(states, layer, imagePositions); diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp index 582480bf41..8535f99b70 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp @@ -24,11 +24,8 @@ public: const float, const uint32_t); - void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const mbgl::ImagePositions&, - const PatternLayerMap&, - std::size_t) override; + void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&, + const PatternLayerMap&, std::size_t) override; bool hasData() const override; diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp index 0ea645a9a0..78c4fb7507 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp @@ -39,11 +39,8 @@ bool HeatmapBucket::hasData() const { return !segments.empty(); } -void HeatmapBucket::addFeature(const GeometryTileFeature& feature, - const GeometryCollection& geometry, - const ImagePositions&, - const PatternLayerMap&, - std::size_t featureIndex) { +void HeatmapBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry, + const ImagePositions&, const PatternLayerMap&, std::size_t featureIndex) { constexpr const uint16_t vertexLength = 4; for (auto& points : geometry) { diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp index 3f9d1cb5c3..04d4170b50 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp @@ -18,11 +18,8 @@ public: HeatmapBucket(const BucketParameters&, const std::vector>&); ~HeatmapBucket() override; - void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const ImagePositions&, - const PatternLayerMap&, - std::size_t) override; + void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&, + const PatternLayerMap&, std::size_t) override; bool hasData() const override; void upload(gfx::UploadPass&) override; diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp index 318af99b0f..f65c239968 100644 --- a/src/mbgl/renderer/buckets/line_bucket.cpp +++ b/src/mbgl/renderer/buckets/line_bucket.cpp @@ -30,10 +30,8 @@ LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layo LineBucket::~LineBucket() = default; -void LineBucket::addFeature(const GeometryTileFeature& feature, - const GeometryCollection& geometryCollection, - const ImagePositions& patternPositions, - const PatternLayerMap& patternDependencies, +void LineBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometryCollection, + const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies, std::size_t index) { for (auto& line : geometryCollection) { addGeometry(line, feature); @@ -49,7 +47,6 @@ void LineBucket::addFeature(const GeometryTileFeature& feature, } } - /* * Sharp corners cause dashed lines to tilt because the distance along the line * is the same at both the inner and outer corners. To improve the appearance of @@ -557,7 +554,8 @@ float LineBucket::getQueryRadius(const RenderLayer& layer) const { return lineWidth / 2.0f + std::abs(offset) + util::length(translate[0], translate[1]); } -void LineBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) { +void LineBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, + const ImagePositions& imagePositions) { auto it = paintPropertyBinders.find(layerID); if (it != paintPropertyBinders.end()) { it->second.updateVertexVectors(states, layer, imagePositions); diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp index 6be35593d9..6343aab2be 100644 --- a/src/mbgl/renderer/buckets/line_bucket.hpp +++ b/src/mbgl/renderer/buckets/line_bucket.hpp @@ -26,11 +26,8 @@ public: const uint32_t overscaling); ~LineBucket() override; - void addFeature(const GeometryTileFeature&, - const GeometryCollection&, - const mbgl::ImagePositions& patternPositions, - const PatternLayerMap&, - std::size_t) override; + void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions& patternPositions, + const PatternLayerMap&, std::size_t) override; bool hasData() const override; diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index 76dadd80bf..b88a026e11 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -141,14 +141,10 @@ GeometryCoordinates projectQueryGeometry(const GeometryCoordinates& queryGeometr return projectedGeometry; } -bool RenderCircleLayer::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float zoom, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4& posMatrix, - const FeatureState& featureState) const { +bool RenderCircleLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, const float zoom, + const TransformState& transformState, const float pixelsToTileUnits, + const mat4& posMatrix, const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; // Translate query geometry const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry( diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp index ee0318da7c..70af20f0cf 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.hpp +++ b/src/mbgl/renderer/layers/render_circle_layer.hpp @@ -18,14 +18,8 @@ private: bool hasCrossfade() const override; void render(PaintParameters&) override; - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const override; + bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const override; // Paint properties style::CirclePaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp index b6ffa3f8f9..fc830e462c 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp @@ -224,14 +224,11 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) { } } -bool RenderFillExtrusionLayer::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4&, - const FeatureState&) const { +bool RenderFillExtrusionLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, const float, + const TransformState& transformState, + const float pixelsToTileUnits, const mat4&, + const FeatureState&) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( queryGeometry, diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp index bad2c26122..0e6a747c71 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp @@ -20,14 +20,8 @@ private: bool is3D() const override; void render(PaintParameters&) override; - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const override; + bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const override; // Paint properties style::FillExtrusionPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 40b3c289f2..e855866eea 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -249,14 +249,10 @@ void RenderFillLayer::render(PaintParameters& parameters) { } } -bool RenderFillLayer::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4&, - const FeatureState&) const { +bool RenderFillLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, const float, + const TransformState& transformState, const float pixelsToTileUnits, + const mat4&, const FeatureState&) const { const auto& evaluated = getEvaluated(evaluatedProperties); auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( queryGeometry, @@ -268,5 +264,4 @@ bool RenderFillLayer::queryIntersectsFeature( return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries()); } - } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp index 182e0c544c..12484dbfb1 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.hpp +++ b/src/mbgl/renderer/layers/render_fill_layer.hpp @@ -21,14 +21,8 @@ private: bool hasCrossfade() const override; void render(PaintParameters&) override; - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const override; + bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const override; // Paint properties style::FillPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 777269f9db..797aedd297 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -219,14 +219,10 @@ void RenderHeatmapLayer::updateColorRamp() { } } -bool RenderHeatmapLayer::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float zoom, - const TransformState&, - const float pixelsToTileUnits, - const mat4&, - const FeatureState&) const { +bool RenderHeatmapLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, const float zoom, + const TransformState&, const float pixelsToTileUnits, const mat4&, + const FeatureState&) const { (void) queryGeometry; (void) feature; (void) zoom; diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp index 1c1eb67ad5..1e9b1063ae 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp @@ -22,14 +22,8 @@ private: void upload(gfx::UploadPass&) override; void render(PaintParameters&) override; - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const override; + bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const override; // Paint properties style::HeatmapPaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index fe3ca00f06..36665c1db4 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -257,14 +257,10 @@ GeometryCollection offsetLine(const GeometryCollection& rings, double offset) { } // namespace -bool RenderLineLayer::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float zoom, - const TransformState& transformState, - const float pixelsToTileUnits, - const mat4&, - const FeatureState& featureState) const { +bool RenderLineLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, const float zoom, + const TransformState& transformState, const float pixelsToTileUnits, + const mat4&, const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; // Translate query geometry auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( @@ -275,10 +271,11 @@ bool RenderLineLayer::queryIntersectsFeature( pixelsToTileUnits); // Evaluate function - auto offset = evaluated.get() - .evaluate(feature, zoom, featureState, style::LineOffset::defaultValue()) * pixelsToTileUnits; + auto offset = + evaluated.get().evaluate(feature, zoom, featureState, style::LineOffset::defaultValue()) * + pixelsToTileUnits; // Test intersection - const float halfWidth = getLineWidth(feature, zoom, featureState) / 2.0 * pixelsToTileUnits; + const auto halfWidth = static_cast(getLineWidth(feature, zoom, featureState) / 2.0 * pixelsToTileUnits); // Apply offset to geometry if (offset != 0.0f && !feature.getGeometries().empty()) { @@ -315,12 +312,13 @@ void RenderLineLayer::updateColorRamp() { } } -float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom, const FeatureState& featureState) const { +float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom, + const FeatureState& featureState) const { const auto& evaluated = static_cast(*evaluatedProperties).evaluated; - float lineWidth = evaluated.get() - .evaluate(feature, zoom, featureState, style::LineWidth::defaultValue()); - float gapWidth = evaluated.get() - .evaluate(feature, zoom, featureState, style::LineGapWidth::defaultValue()); + float lineWidth = + evaluated.get().evaluate(feature, zoom, featureState, style::LineWidth::defaultValue()); + float gapWidth = + evaluated.get().evaluate(feature, zoom, featureState, style::LineGapWidth::defaultValue()); if (gapWidth) { return gapWidth + 2 * lineWidth; } else { diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp index d4d84eb34e..1914a82b77 100644 --- a/src/mbgl/renderer/layers/render_line_layer.hpp +++ b/src/mbgl/renderer/layers/render_line_layer.hpp @@ -24,14 +24,8 @@ private: void upload(gfx::UploadPass&) override; void render(PaintParameters&) override; - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const override; + bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const override; // Paint properties style::LinePaintProperties::Unevaluated unevaluated; diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp index fdfbc99642..1a36f8a2e5 100644 --- a/src/mbgl/renderer/paint_property_binder.hpp +++ b/src/mbgl/renderer/paint_property_binder.hpp @@ -105,15 +105,11 @@ public: virtual ~PaintPropertyBinder() = default; - virtual void populateVertexVector(const GeometryTileFeature& feature, - std::size_t length, std::size_t index, - const ImagePositions&, - const optional&, + virtual void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, + const ImagePositions&, const optional&, const style::expression::Value&) = 0; - virtual void updateVertexVectors(const FeatureStates&, - const GeometryTileLayer&, - const ImagePositions&) {} + virtual void updateVertexVectors(const FeatureStates&, const GeometryTileLayer&, const ImagePositions&) {} virtual void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) = 0; @@ -135,7 +131,8 @@ public: : constant(std::move(constant_)) { } - void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, + const optional&, const style::expression::Value&) override {} void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {} void upload(gfx::UploadPass&) override {} void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; @@ -163,7 +160,8 @@ public: : constant(std::move(constant_)), constantPatternPositions({}) { } - void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional&, const style::expression::Value&) override {} + void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, + const optional&, const style::expression::Value&) override {} void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {} void upload(gfx::UploadPass&) override {} @@ -206,7 +204,9 @@ public: defaultValue(std::move(defaultValue_)) { } void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; - void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { + void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, + const ImagePositions&, const optional&, + const style::expression::Value& formattedSection) override { using style::expression::EvaluationContext; auto evaluated = expression.evaluate(EvaluationContext(&feature).withFormattedSection(&formattedSection), defaultValue); this->statistics.add(evaluated); @@ -217,11 +217,12 @@ public: } optional idStr = featureIDtoString(feature.getID()); if (idStr) { - featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length }); + featureMap[*idStr].emplace_back(FeatureVertexRange{index, elements, length}); } } - void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override { + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, + const ImagePositions&) override { for (const auto& it : states) { const auto positions = featureMap.find(it.first); if (positions == featureMap.end()) { @@ -237,14 +238,15 @@ public: } } - void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override { + void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, + const FeatureState& state) override { using style::expression::EvaluationContext; auto evaluated = expression.evaluate(EvaluationContext(&feature).withFeatureState(&state), defaultValue); this->statistics.add(evaluated); auto value = attributeValue(evaluated); for (std::size_t i = start; i < end; ++i) { - vertexVector.at(i) = BaseVertex { value }; + vertexVector.at(i) = BaseVertex{value}; } } @@ -297,7 +299,9 @@ public: zoomRange({zoom, zoom + 1}) { } void setPatternParameters(const optional&, const optional&, const CrossfadeParameters&) override {}; - void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional&, const style::expression::Value& formattedSection) override { + void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, + const ImagePositions&, const optional&, + const style::expression::Value& formattedSection) override { using style::expression::EvaluationContext; Range range = { expression.evaluate(EvaluationContext(zoomRange.min, &feature).withFormattedSection(&formattedSection), defaultValue), @@ -314,11 +318,12 @@ public: } optional idStr = featureIDtoString(feature.getID()); if (idStr) { - featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length }); + featureMap[*idStr].emplace_back(FeatureVertexRange{index, elements, length}); } } - void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override { + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, + const ImagePositions&) override { for (const auto& it : states) { const auto positions = featureMap.find(it.first); if (positions == featureMap.end()) { @@ -334,20 +339,19 @@ public: } } - void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override { + void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, + const FeatureState& state) override { using style::expression::EvaluationContext; Range range = { - expression.evaluate(EvaluationContext(zoomRange.min, &feature, &state), defaultValue), - expression.evaluate(EvaluationContext(zoomRange.max, &feature, &state), defaultValue), + expression.evaluate(EvaluationContext(zoomRange.min, &feature, &state), defaultValue), + expression.evaluate(EvaluationContext(zoomRange.max, &feature, &state), defaultValue), }; this->statistics.add(range.min); this->statistics.add(range.max); - AttributeValue value = zoomInterpolatedAttributeValue( - attributeValue(range.min), - attributeValue(range.max)); + AttributeValue value = zoomInterpolatedAttributeValue(attributeValue(range.min), attributeValue(range.max)); for (std::size_t i = start; i < end; ++i) { - vertexVector.at(i) = Vertex { value }; + vertexVector.at(i) = Vertex{value}; } } @@ -413,8 +417,10 @@ public: crossfade = crossfade_; }; - void populateVertexVector(const GeometryTileFeature&, std::size_t length, std::size_t /* index */, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value&) override { - + void populateVertexVector(const GeometryTileFeature&, std::size_t length, std::size_t /* index */, + const ImagePositions& patternPositions, + const optional& patternDependencies, + const style::expression::Value&) override { if (!patternDependencies || patternDependencies->mid.empty()) { // Unlike other propperties with expressions that evaluate to null, the default value for `*-pattern` properties is an empty // string and will not have a valid entry in patternPositions. We still need to populate the attribute buffers to avoid crashes @@ -584,16 +590,18 @@ public: PaintPropertyBinders(PaintPropertyBinders&&) = default; PaintPropertyBinders(const PaintPropertyBinders&) = delete; - void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions& patternPositions, const optional& patternDependencies, const style::expression::Value& formattedSection = {}) { - util::ignore({ - (binders.template get()->populateVertexVector(feature, length, index, patternPositions, patternDependencies, formattedSection), 0)... - }); + void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, std::size_t index, + const ImagePositions& patternPositions, + const optional& patternDependencies, + const style::expression::Value& formattedSection = {}) { + util::ignore({(binders.template get()->populateVertexVector(feature, length, index, patternPositions, + patternDependencies, formattedSection), + 0)...}); } - void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions& imagePositions) { - util::ignore({ - (binders.template get()->updateVertexVectors(states, layer, imagePositions), 0)... - }); + void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, + const ImagePositions& imagePositions) { + util::ignore({(binders.template get()->updateVertexVectors(states, layer, imagePositions), 0)...}); } void setPatternParameters(const optional& posA, const optional& posB, const CrossfadeParameters& crossfade) const { diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp index 2e47e6c854..1198e43aae 100644 --- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp +++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp @@ -52,12 +52,10 @@ public: template T evaluate(const Feature& feature, float zoom, const FeatureState& featureState, T defaultValue) const { - return this->match( - [&] (const T& constant_) { return constant_; }, - [&] (const style::PropertyExpression& expression) { - return expression.evaluate(zoom, feature, featureState, defaultValue); - } - ); + return this->match([&](const T& constant_) { return constant_; }, + [&](const style::PropertyExpression& expression) { + return expression.evaluate(zoom, feature, featureState, defaultValue); + }); } }; diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp index 2b65d069ae..ba3c638f88 100644 --- a/src/mbgl/renderer/render_layer.hpp +++ b/src/mbgl/renderer/render_layer.hpp @@ -88,14 +88,10 @@ public: // Check wether the given geometry intersects // with the feature - virtual bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const TransformState&, - const float, - const mat4&, - const FeatureState&) const { return false; }; + virtual bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, + const TransformState&, const float, const mat4&, const FeatureState&) const { + return false; + }; virtual void prepare(const LayerPrepareParameters&); diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp index 6bccee7798..a1280331b1 100644 --- a/src/mbgl/renderer/render_orchestrator.cpp +++ b/src/mbgl/renderer/render_orchestrator.cpp @@ -562,17 +562,14 @@ FeatureExtensionValue RenderOrchestrator::queryFeatureExtensions(const std::stri return {}; } -void RenderOrchestrator::setFeatureState(const std::string& sourceID, - const optional& sourceLayerID, - const std::string& featureID, - const FeatureState& state) { +void RenderOrchestrator::setFeatureState(const std::string& sourceID, const optional& sourceLayerID, + const std::string& featureID, const FeatureState& state) { if (RenderSource* renderSource = getRenderSource(sourceID)) { renderSource->setFeatureState(sourceLayerID, featureID, state); } } -void RenderOrchestrator::getFeatureState(FeatureState& state, - const std::string& sourceID, +void RenderOrchestrator::getFeatureState(FeatureState& state, const std::string& sourceID, const optional& sourceLayerID, const std::string& featureID) const { if (RenderSource* renderSource = getRenderSource(sourceID)) { @@ -580,8 +577,7 @@ void RenderOrchestrator::getFeatureState(FeatureState& state, } } -void RenderOrchestrator::removeFeatureState(const std::string& sourceID, - const optional& sourceLayerID, +void RenderOrchestrator::removeFeatureState(const std::string& sourceID, const optional& sourceLayerID, const optional& featureID, const optional& stateKey) { if (RenderSource* renderSource = getRenderSource(sourceID)) { diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp index f42a40ec33..34b623348f 100644 --- a/src/mbgl/renderer/render_orchestrator.hpp +++ b/src/mbgl/renderer/render_orchestrator.hpp @@ -64,20 +64,14 @@ public: const std::string& extensionField, const optional>& args) const; - void setFeatureState(const std::string& sourceID, - const optional& layerID, - const std::string& featureID, - const FeatureState& state); - - void getFeatureState(FeatureState& state, - const std::string& sourceID, - const optional& layerID, + void setFeatureState(const std::string& sourceID, const optional& layerID, + const std::string& featureID, const FeatureState& state); + + void getFeatureState(FeatureState& state, const std::string& sourceID, const optional& layerID, const std::string& featureID) const; - void removeFeatureState(const std::string& sourceID, - const optional& sourceLayerID, - const optional& featureID, - const optional& stateKey); + void removeFeatureState(const std::string& sourceID, const optional& sourceLayerID, + const optional& featureID, const optional& stateKey); void reduceMemoryUse(); void dumpDebugLogs(); diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp index 39ca97d563..ee90e1c4d0 100644 --- a/src/mbgl/renderer/render_source.hpp +++ b/src/mbgl/renderer/render_source.hpp @@ -93,16 +93,11 @@ public: return {}; } - virtual void setFeatureState(const optional&, - const std::string&, - const FeatureState&) {} + virtual void setFeatureState(const optional&, const std::string&, const FeatureState&) {} - virtual void getFeatureState(FeatureState&, - const optional&, - const std::string&) const {} + virtual void getFeatureState(FeatureState&, const optional&, const std::string&) const {} - virtual void removeFeatureState(const optional&, - const optional&, + virtual void removeFeatureState(const optional&, const optional&, const optional&) {} virtual void reduceMemoryUse() = 0; diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp index a91a0098ca..cf4072036c 100644 --- a/src/mbgl/renderer/renderer.cpp +++ b/src/mbgl/renderer/renderer.cpp @@ -109,24 +109,18 @@ FeatureExtensionValue Renderer::queryFeatureExtensions(const std::string& source return impl->orchestrator.queryFeatureExtensions(sourceID, feature, extension, extensionField, args); } -void Renderer::setFeatureState(const std::string& sourceID, - const optional& sourceLayerID, - const std::string& featureID, - const FeatureState& state) { +void Renderer::setFeatureState(const std::string& sourceID, const optional& sourceLayerID, + const std::string& featureID, const FeatureState& state) { impl->orchestrator.setFeatureState(sourceID, sourceLayerID, featureID, state); } -void Renderer::getFeatureState(FeatureState& state, - const std::string& sourceID, - const optional& sourceLayerID, - const std::string& featureID) const { +void Renderer::getFeatureState(FeatureState& state, const std::string& sourceID, + const optional& sourceLayerID, const std::string& featureID) const { impl->orchestrator.getFeatureState(state, sourceID, sourceLayerID, featureID); } -void Renderer::removeFeatureState(const std::string& sourceID, - const optional& sourceLayerID, - const optional& featureID, - const optional& stateKey) { +void Renderer::removeFeatureState(const std::string& sourceID, const optional& sourceLayerID, + const optional& featureID, const optional& stateKey) { impl->orchestrator.removeFeatureState(sourceID, sourceLayerID, featureID, stateKey); } diff --git a/src/mbgl/renderer/source_state.cpp b/src/mbgl/renderer/source_state.cpp index c1b95aca68..d057c211b5 100644 --- a/src/mbgl/renderer/source_state.cpp +++ b/src/mbgl/renderer/source_state.cpp @@ -1,11 +1,12 @@ +#include #include #include -#include #include namespace mbgl { -void SourceFeatureState::updateState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& newState) { +void SourceFeatureState::updateState(const optional& sourceLayerID, const std::string& featureID, + const FeatureState& newState) { std::string sourceLayer = sourceLayerID.value_or(std::string()); for (const auto& state : newState) { auto& layerStates = stateChanges[sourceLayer]; @@ -14,9 +15,11 @@ void SourceFeatureState::updateState(const optional& sourceLayerID, } } -void SourceFeatureState::getState(FeatureState& result, const optional& sourceLayerID, const std::string& featureID) const { +void SourceFeatureState::getState(FeatureState& result, const optional& sourceLayerID, + const std::string& featureID) const { std::string sourceLayer = sourceLayerID.value_or(std::string()); - FeatureState current, changes; + FeatureState current; + FeatureState changes; auto layerStates = currentStates.find(sourceLayer); if (layerStates != currentStates.end()) { const auto currentStateEntry = layerStates->second.find(featureID); @@ -61,7 +64,7 @@ void SourceFeatureState::coalesceChanges(std::vector& tiles) { for (const auto& layerStatesEntry : deletedStates) { const auto& sourceLayer = layerStatesEntry.first; - FeatureStates layerStates = { {}, {} }; + FeatureStates layerStates = {{}, {}}; if (deletedStates[sourceLayer].empty()) { for (const auto& featureStatesEntry : currentStates[sourceLayer]) { @@ -89,25 +92,31 @@ void SourceFeatureState::coalesceChanges(std::vector& tiles) { stateChanges.clear(); deletedStates.clear(); - if (changes.empty()) return; + if (changes.empty()) { + return; + } for (auto& tile : tiles) { tile.setFeatureState(changes); } } -void SourceFeatureState::removeState(const optional& sourceLayerID, const optional& featureID, const optional& stateKey) { +void SourceFeatureState::removeState(const optional& sourceLayerID, const optional& featureID, + const optional& stateKey) { std::string sourceLayer = sourceLayerID.value_or(std::string()); bool sourceLayerDeleted = (deletedStates.count(sourceLayer) > 0) && deletedStates[sourceLayer].empty(); - if (sourceLayerDeleted) return; + if (sourceLayerDeleted) { + return; + } if (stateKey && featureID) { if ((deletedStates.count(sourceLayer) == 0) && (deletedStates[sourceLayer].count(*featureID)) == 0) { deletedStates[sourceLayer][*featureID][*stateKey] = {}; } } else if (featureID) { - bool updateInQueue = stateChanges.count(sourceLayer) && stateChanges[sourceLayer].count(*featureID); + bool updateInQueue = + (stateChanges.count(sourceLayer) != 0U) && (stateChanges[sourceLayer].count(*featureID) != 0U); if (updateInQueue) { for (const auto& changeEntry : stateChanges[sourceLayer][*featureID]) { deletedStates[sourceLayer][*featureID][changeEntry.first] = {}; diff --git a/src/mbgl/renderer/source_state.hpp b/src/mbgl/renderer/source_state.hpp index 61546aff62..7217302630 100644 --- a/src/mbgl/renderer/source_state.hpp +++ b/src/mbgl/renderer/source_state.hpp @@ -6,16 +6,17 @@ namespace mbgl { class RenderTile; -using namespace style::conversion; class SourceFeatureState { public: SourceFeatureState() = default; ~SourceFeatureState() = default; - void updateState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& newState); + void updateState(const optional& sourceLayerID, const std::string& featureID, + const FeatureState& newState); void getState(FeatureState& result, const optional& sourceLayerID, const std::string& featureID) const; - void removeState(const optional& sourceLayerID, const optional& featureID, const optional& stateKey); + void removeState(const optional& sourceLayerID, const optional& featureID, + const optional& stateKey); void coalesceChanges(std::vector& tiles); diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index 3c6eff0855..221f976c50 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -134,14 +134,12 @@ std::vector RenderTileSource::querySourceFeatures(const SourceQueryOpti return tilePyramid.querySourceFeatures(options); } -void RenderTileSource::setFeatureState(const optional& sourceLayerID, - const std::string& featureID, +void RenderTileSource::setFeatureState(const optional& sourceLayerID, const std::string& featureID, const FeatureState& state) { featureState.updateState(sourceLayerID, featureID, state); } -void RenderTileSource::getFeatureState(FeatureState& state, - const optional& sourceLayerID, +void RenderTileSource::getFeatureState(FeatureState& state, const optional& sourceLayerID, const std::string& featureID) const { featureState.getState(state, sourceLayerID, featureID); } diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp index 48eea8558c..7756bd8ed0 100644 --- a/src/mbgl/renderer/sources/render_tile_source.hpp +++ b/src/mbgl/renderer/sources/render_tile_source.hpp @@ -1,9 +1,9 @@ #pragma once #include +#include #include #include -#include namespace mbgl { @@ -35,17 +35,12 @@ public: std::vector querySourceFeatures(const SourceQueryOptions&) const override; - virtual void setFeatureState(const optional&, - const std::string&, - const FeatureState&) override; + void setFeatureState(const optional&, const std::string&, const FeatureState&) override; - virtual void getFeatureState(FeatureState& state, - const optional&, - const std::string&) const override; + void getFeatureState(FeatureState& state, const optional&, const std::string&) const override; - virtual void removeFeatureState(const optional&, - const optional&, - const optional&) override; + void removeFeatureState(const optional&, const optional&, + const optional&) override; void reduceMemoryUse() override; void dumpDebugLogs() const override; @@ -56,7 +51,9 @@ protected: Immutable> renderTiles; mutable RenderTiles filteredRenderTiles; mutable RenderTiles renderTilesSortedByY; - float bearing = 0.0f; + +private: + float bearing = 0.0F; SourceFeatureState featureState; }; diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp index db3e731605..2bf6e2e1a9 100644 --- a/src/mbgl/renderer/tile_pyramid.cpp +++ b/src/mbgl/renderer/tile_pyramid.cpp @@ -278,13 +278,10 @@ void TilePyramid::handleWrapJump(float lng) { } } - -std::unordered_map> TilePyramid::queryRenderedFeatures(const ScreenLineString& geometry, - const TransformState& transformState, - const std::unordered_map& layers, - const RenderedQueryOptions& options, - const mat4& projMatrix, - const SourceFeatureState& featureState) const { +std::unordered_map> TilePyramid::queryRenderedFeatures( + const ScreenLineString& geometry, const TransformState& transformState, + const std::unordered_map& layers, const RenderedQueryOptions& options, + const mat4& projMatrix, const SourceFeatureState& featureState) const { std::unordered_map> result; if (renderedTiles.empty() || geometry.empty()) { return result; @@ -332,12 +329,7 @@ std::unordered_map> TilePyramid::queryRendered tileSpaceQueryGeometry.push_back(TileCoordinate::toGeometryCoordinate(id, c)); } - tile.queryRenderedFeatures(result, - tileSpaceQueryGeometry, - transformState, - layers, - options, - projMatrix, + tile.queryRenderedFeatures(result, tileSpaceQueryGeometry, transformState, layers, options, projMatrix, featureState); } diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp index bb0b7e9f67..3b5cab5d6c 100644 --- a/src/mbgl/renderer/tile_pyramid.hpp +++ b/src/mbgl/renderer/tile_pyramid.hpp @@ -49,13 +49,10 @@ public: void handleWrapJump(float lng); - std::unordered_map> - queryRenderedFeatures(const ScreenLineString& geometry, - const TransformState& transformState, - const std::unordered_map&, - const RenderedQueryOptions& options, - const mat4& projMatrix, - const mbgl::SourceFeatureState& featureState) const; + std::unordered_map> queryRenderedFeatures( + const ScreenLineString& geometry, const TransformState& transformState, + const std::unordered_map&, const RenderedQueryOptions& options, + const mat4& projMatrix, const mbgl::SourceFeatureState& featureState) const; std::vector querySourceFeatures(const SourceQueryOptions&) const; diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp index 8bd21bdad7..c2bc511e41 100644 --- a/src/mbgl/style/expression/compound_expression.cpp +++ b/src/mbgl/style/expression/compound_expression.cpp @@ -676,16 +676,17 @@ const auto& errorCompoundExpression() { } const auto& featureStateCompoundExpression() { - static auto signature = detail::makeSignature("feature-state", [](const EvaluationContext& params, const std::string& key) -> Result { - mbgl::Value state; - if (params.featureState) { - auto it = params.featureState->find(key); - if (it != params.featureState->end()) { - state = mbgl::Value(it->second); + static auto signature = detail::makeSignature( + "feature-state", [](const EvaluationContext& params, const std::string& key) -> Result { + mbgl::Value state; + if (params.featureState != nullptr) { + auto it = params.featureState->find(key); + if (it != params.featureState->end()) { + state = mbgl::Value(it->second); + } } - } - return toExpressionValue(state); - }); + return toExpressionValue(state); + }); return signature; } @@ -886,82 +887,83 @@ const auto& filterInCompoundExpression() { } using ParseCompoundFunction = const std::unique_ptr& (*)(); -MAPBOX_ETERNAL_CONSTEXPR const auto compoundExpressionRegistry = mapbox::eternal::hash_map({ - { "e", eCompoundExpression }, - { "pi", piCompoundExpression }, - { "ln2", ln2CompoundExpression }, - { "typeof", typeofCompoundExpression }, - { "to-rgba", toRgbaCompoundExpression }, - { "rgba", rgbaCompoundExpression }, - { "rgb", rgbCompoundExpression }, - { "zoom", zoomCompoundExpression }, - { "heatmap-density", heatmapDensityCompoundExpression }, - { "line-progress", lineProgressCompoundExpression }, - { "accumulated", accumulatedCompoundExpression }, - { "has", hasContextCompoundExpression }, - { "has", hasObjectCompoundExpression }, - { "get", getContextCompoundExpression }, - { "get", getObjectCompoundExpression }, - { "properties", propertiesCompoundExpression }, - { "geometry-type", geometryTypeCompoundExpression }, - { "id", idCompoundExpression }, - { "+", plusCompoundExpression }, - { "-", minusCompoundExpression }, - { "-", negateCompoundExpression }, - { "*", multiplyCompoundExpression }, - { "/", divideCompoundExpression }, - { "%", modCompoundExpression }, - { "^", powCompoundExpression }, - { "sqrt", sqrtCompoundExpression }, - { "log10", log10CompoundExpression }, - { "ln", lnCompoundExpression }, - { "log2", log2CompoundExpression }, - { "sin", sinCompoundExpression }, - { "cos", cosCompoundExpression }, - { "tan", tanCompoundExpression }, - { "asin", asinCompoundExpression }, - { "acos", acosCompoundExpression }, - { "atan", atanCompoundExpression }, - { "min", minCompoundExpression }, - { "max", maxCompoundExpression }, - { "round", roundCompoundExpression }, - { "floor", floorCompoundExpression }, - { "ceil", ceilCompoundExpression }, - { "abs", absCompoundExpression }, - { "!", notCompoundExpression }, - { "is-supported-script", isSupportedScriptCompoundExpression }, - { "upcase", upcaseCompoundExpression }, - { "downcase", downcaseCompoundExpression }, - { "concat", concatCompoundExpression }, - { "resolved-locale", resolvedLocaleCompoundExpression }, - { "error", errorCompoundExpression }, - { "feature-state", featureStateCompoundExpression }, - // Legacy Filters - { "filter-==", filterEqualsCompoundExpression }, - { "filter-id-==", filterIdEqualsCompoundExpression }, - { "filter-type-==", filterTypeEqualsCompoundExpression }, - { "filter-<", filterLessThanNumberCompoundExpression }, - { "filter-<", filterLessThanStringCompoundExpression }, - { "filter-id-<", filterIdLessThanNumberCompoundExpression }, - { "filter-id-<", filterIdLessThanStringCompoundExpression }, - { "filter->", filterMoreThanNumberCompoundExpression }, - { "filter->", filterMoreThanStringCompoundExpression }, - { "filter-id->", filterIdMoreThanNumberCompoundExpression }, - { "filter-id->", filterIdMoreThanStringCompoundExpression }, - { "filter-<=", filterLessOrEqualThanNumberCompoundExpression }, - { "filter-<=", filterLessOrEqualThanStringCompoundExpression }, - { "filter-id-<=", filterIdLessOrEqualThanNumberCompoundExpression }, - { "filter-id-<=", filterIdLessOrEqualThanStringCompoundExpression }, - { "filter->=", filterGreaterOrEqualThanNumberCompoundExpression }, - { "filter->=", filterGreaterOrEqualThanStringCompoundExpression }, - { "filter-id->=", filterIdGreaterOrEqualThanNumberCompoundExpression }, - { "filter-id->=", filterIdGreaterOrEqualThanStringCompoundExpression }, - { "filter-has", filterHasCompoundExpression }, - { "filter-has-id", filterHasIdCompoundExpression }, - { "filter-type-in", filterTypeInCompoundExpression }, - { "filter-id-in", filterIdInCompoundExpression }, - { "filter-in", filterInCompoundExpression }, -}); +MAPBOX_ETERNAL_CONSTEXPR const auto compoundExpressionRegistry = + mapbox::eternal::hash_map({ + {"e", eCompoundExpression}, + {"pi", piCompoundExpression}, + {"ln2", ln2CompoundExpression}, + {"typeof", typeofCompoundExpression}, + {"to-rgba", toRgbaCompoundExpression}, + {"rgba", rgbaCompoundExpression}, + {"rgb", rgbCompoundExpression}, + {"zoom", zoomCompoundExpression}, + {"heatmap-density", heatmapDensityCompoundExpression}, + {"line-progress", lineProgressCompoundExpression}, + {"accumulated", accumulatedCompoundExpression}, + {"has", hasContextCompoundExpression}, + {"has", hasObjectCompoundExpression}, + {"get", getContextCompoundExpression}, + {"get", getObjectCompoundExpression}, + {"properties", propertiesCompoundExpression}, + {"geometry-type", geometryTypeCompoundExpression}, + {"id", idCompoundExpression}, + {"+", plusCompoundExpression}, + {"-", minusCompoundExpression}, + {"-", negateCompoundExpression}, + {"*", multiplyCompoundExpression}, + {"/", divideCompoundExpression}, + {"%", modCompoundExpression}, + {"^", powCompoundExpression}, + {"sqrt", sqrtCompoundExpression}, + {"log10", log10CompoundExpression}, + {"ln", lnCompoundExpression}, + {"log2", log2CompoundExpression}, + {"sin", sinCompoundExpression}, + {"cos", cosCompoundExpression}, + {"tan", tanCompoundExpression}, + {"asin", asinCompoundExpression}, + {"acos", acosCompoundExpression}, + {"atan", atanCompoundExpression}, + {"min", minCompoundExpression}, + {"max", maxCompoundExpression}, + {"round", roundCompoundExpression}, + {"floor", floorCompoundExpression}, + {"ceil", ceilCompoundExpression}, + {"abs", absCompoundExpression}, + {"!", notCompoundExpression}, + {"is-supported-script", isSupportedScriptCompoundExpression}, + {"upcase", upcaseCompoundExpression}, + {"downcase", downcaseCompoundExpression}, + {"concat", concatCompoundExpression}, + {"resolved-locale", resolvedLocaleCompoundExpression}, + {"error", errorCompoundExpression}, + {"feature-state", featureStateCompoundExpression}, + // Legacy Filters + {"filter-==", filterEqualsCompoundExpression}, + {"filter-id-==", filterIdEqualsCompoundExpression}, + {"filter-type-==", filterTypeEqualsCompoundExpression}, + {"filter-<", filterLessThanNumberCompoundExpression}, + {"filter-<", filterLessThanStringCompoundExpression}, + {"filter-id-<", filterIdLessThanNumberCompoundExpression}, + {"filter-id-<", filterIdLessThanStringCompoundExpression}, + {"filter->", filterMoreThanNumberCompoundExpression}, + {"filter->", filterMoreThanStringCompoundExpression}, + {"filter-id->", filterIdMoreThanNumberCompoundExpression}, + {"filter-id->", filterIdMoreThanStringCompoundExpression}, + {"filter-<=", filterLessOrEqualThanNumberCompoundExpression}, + {"filter-<=", filterLessOrEqualThanStringCompoundExpression}, + {"filter-id-<=", filterIdLessOrEqualThanNumberCompoundExpression}, + {"filter-id-<=", filterIdLessOrEqualThanStringCompoundExpression}, + {"filter->=", filterGreaterOrEqualThanNumberCompoundExpression}, + {"filter->=", filterGreaterOrEqualThanStringCompoundExpression}, + {"filter-id->=", filterIdGreaterOrEqualThanNumberCompoundExpression}, + {"filter-id->=", filterIdGreaterOrEqualThanStringCompoundExpression}, + {"filter-has", filterHasCompoundExpression}, + {"filter-has-id", filterHasIdCompoundExpression}, + {"filter-type-in", filterTypeInCompoundExpression}, + {"filter-id-in", filterIdInCompoundExpression}, + {"filter-in", filterInCompoundExpression}, + }); using namespace mbgl::style::conversion; diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp index 5f8215c55f..4c4684c86a 100644 --- a/src/mbgl/style/expression/is_constant.cpp +++ b/src/mbgl/style/expression/is_constant.cpp @@ -17,12 +17,7 @@ bool isFeatureConstant(const Expression& expression) { return false; } else if (name == "has" && parameterCount && *parameterCount == 1) { return false; - } else if ( - name == "properties" || - name == "geometry-type" || - name == "id" || - name == "feature-state" - ) { + } else if (name == "properties" || name == "geometry-type" || name == "id" || name == "feature-state") { return false; } else if (0u == name.rfind(filter, 0u)) { // Legacy filters begin with "filter-" and are never constant. diff --git a/src/mbgl/style/properties.hpp b/src/mbgl/style/properties.hpp index b07456a96d..db0e54330c 100644 --- a/src/mbgl/style/properties.hpp +++ b/src/mbgl/style/properties.hpp @@ -183,13 +183,8 @@ public: template static T evaluate(float z, const GeometryTileFeature& feature, const FeatureState& state, const PossiblyEvaluatedPropertyValue& v, const T& defaultValue) { - return v.match( - [&] (const T& t) { - return t; - }, - [&] (const PropertyExpression& t) { - return t.evaluate(z, feature, state, defaultValue); - }); + return v.match([&](const T& t) { return t; }, + [&](const PropertyExpression& t) { return t.evaluate(z, feature, state, defaultValue); }); } template diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp index 2076c73337..9f9c41d229 100644 --- a/src/mbgl/tile/geometry_tile.cpp +++ b/src/mbgl/tile/geometry_tile.cpp @@ -302,15 +302,11 @@ float GeometryTile::getQueryPadding(const std::unordered_map>& result, - const GeometryCoordinates& queryGeometry, - const TransformState& transformState, - const std::unordered_map& layers, - const RenderedQueryOptions& options, - const mat4& projMatrix, - const SourceFeatureState& featureState) { - +void GeometryTile::queryRenderedFeatures(std::unordered_map>& result, + const GeometryCoordinates& queryGeometry, const TransformState& transformState, + const std::unordered_map& layers, + const RenderedQueryOptions& options, const mat4& projMatrix, + const SourceFeatureState& featureState) { if (!getData()) return; const float queryPadding = getQueryPadding(layers); @@ -319,17 +315,10 @@ void GeometryTile::queryRenderedFeatures( transformState.matrixFor(posMatrix, id.toUnwrapped()); matrix::multiply(posMatrix, projMatrix, posMatrix); - layoutResult->featureIndex->query(result, - queryGeometry, - transformState, - posMatrix, - util::tileSize * id.overscaleFactor(), - std::pow(2, transformState.getZoom() - id.overscaledZ), - options, - id.toUnwrapped(), - layers, - queryPadding * transformState.maxPitchScaleFactor(), - featureState); + layoutResult->featureIndex->query(result, queryGeometry, transformState, posMatrix, + util::tileSize * id.overscaleFactor(), + std::pow(2, transformState.getZoom() - id.overscaledZ), options, id.toUnwrapped(), + layers, queryPadding * transformState.maxPitchScaleFactor(), featureState); } void GeometryTile::querySourceFeatures( @@ -391,7 +380,9 @@ void GeometryTile::performedFadePlacement() { void GeometryTile::setFeatureState(const LayerFeatureStates& states) { auto layers = getData(); - if (!layers || states.empty() || !layoutResult) return; + if ((layers == nullptr) || states.empty() || !layoutResult) { + return; + } auto& layerIdToLayerRenderData = layoutResult->layerRenderData; for (auto& layer : layerIdToLayerRenderData) { @@ -400,9 +391,13 @@ void GeometryTile::setFeatureState(const LayerFeatureStates& states) { if (sourceLayer) { const auto& sourceLayerID = sourceLayer->getName(); auto entry = states.find(sourceLayerID); - if (entry == states.end()) continue; + if (entry == states.end()) { + continue; + } const auto& featureStates = entry->second; - if (featureStates.empty()) continue; + if (featureStates.empty()) { + continue; + } auto bucket = layer.second.bucket; if (bucket && bucket->hasData()) { diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp index 4415e0a1fa..566b359547 100644 --- a/src/mbgl/tile/geometry_tile.hpp +++ b/src/mbgl/tile/geometry_tile.hpp @@ -48,14 +48,11 @@ public: bool layerPropertiesUpdated(const Immutable&) override; - void queryRenderedFeatures( - std::unordered_map>& result, - const GeometryCoordinates& queryGeometry, - const TransformState&, - const std::unordered_map& layers, - const RenderedQueryOptions& options, - const mat4& projMatrix, - const SourceFeatureState& featureState) override; + void queryRenderedFeatures(std::unordered_map>& result, + const GeometryCoordinates& queryGeometry, const TransformState&, + const std::unordered_map& layers, + const RenderedQueryOptions& options, const mat4& projMatrix, + const SourceFeatureState& featureState) override; void querySourceFeatures( std::vector& result, @@ -94,7 +91,7 @@ public: const std::shared_ptr getFeatureIndex() const; const std::string sourceID; - + void setFeatureState(const LayerFeatureStates&) override; protected: diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp index ce883ad93f..f6af61eb3c 100644 --- a/src/mbgl/tile/geometry_tile_worker.cpp +++ b/src/mbgl/tile/geometry_tile_worker.cpp @@ -384,7 +384,7 @@ void GeometryTileWorker::parse() { continue; const GeometryCollection& geometries = feature->getGeometries(); - bucket->addFeature(*feature, geometries, {}, PatternLayerMap (), i); + bucket->addFeature(*feature, geometries, {}, PatternLayerMap(), i); featureIndex->insert(geometries, i, sourceLayerID, leaderImpl.id); } diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp index 87223c7933..2ebbf76c2a 100644 --- a/src/mbgl/tile/tile.cpp +++ b/src/mbgl/tile/tile.cpp @@ -39,14 +39,9 @@ void Tile::dumpDebugLogs() const { Log::Info(Event::General, "Tile::complete: %s", isComplete() ? "yes" : "no"); } -void Tile::queryRenderedFeatures( - std::unordered_map>&, - const GeometryCoordinates&, - const TransformState&, - const std::unordered_map&, - const RenderedQueryOptions&, - const mat4&, - const SourceFeatureState&) {} +void Tile::queryRenderedFeatures(std::unordered_map>&, const GeometryCoordinates&, + const TransformState&, const std::unordered_map&, + const RenderedQueryOptions&, const mat4&, const SourceFeatureState&) {} float Tile::getQueryPadding(const std::unordered_map&) { return 0; diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp index eda4667027..b73383f989 100644 --- a/src/mbgl/tile/tile.hpp +++ b/src/mbgl/tile/tile.hpp @@ -68,14 +68,11 @@ public: virtual void setLayers(const std::vector>&) {} virtual void setMask(TileMask&&) {} - virtual void queryRenderedFeatures( - std::unordered_map>& result, - const GeometryCoordinates& queryGeometry, - const TransformState&, - const std::unordered_map&, - const RenderedQueryOptions& options, - const mat4& projMatrix, - const SourceFeatureState& featureState); + virtual void queryRenderedFeatures(std::unordered_map>& result, + const GeometryCoordinates& queryGeometry, const TransformState&, + const std::unordered_map&, + const RenderedQueryOptions& options, const mat4& projMatrix, + const SourceFeatureState& featureState); virtual void querySourceFeatures( std::vector& result, -- cgit v1.2.1 From 224d49cc9083f8ecb418a68ae0fea839bc51def6 Mon Sep 17 00:00:00 2001 From: Mikhail Pozdnyakov Date: Tue, 17 Sep 2019 18:51:53 +0300 Subject: [core] Check layer compatibility with source --- src/mbgl/annotation/annotation_source.cpp | 7 ++++- src/mbgl/annotation/annotation_source.hpp | 7 ++--- src/mbgl/style/sources/custom_geometry_source.cpp | 18 ++++++++--- src/mbgl/style/sources/geojson_source.cpp | 15 ++++++--- src/mbgl/style/sources/image_source.cpp | 9 ++++-- src/mbgl/style/sources/raster_dem_source.cpp | 11 +++++-- src/mbgl/style/sources/raster_source.cpp | 15 ++++++--- src/mbgl/style/sources/vector_source.cpp | 17 +++++++--- src/mbgl/style/style_impl.cpp | 38 ++++++++++++++--------- 9 files changed, 94 insertions(+), 43 deletions(-) (limited to 'src') diff --git a/src/mbgl/annotation/annotation_source.cpp b/src/mbgl/annotation/annotation_source.cpp index 68f36f2d3a..7a137f1881 100644 --- a/src/mbgl/annotation/annotation_source.cpp +++ b/src/mbgl/annotation/annotation_source.cpp @@ -1,5 +1,6 @@ -#include #include +#include +#include namespace mbgl { @@ -21,4 +22,8 @@ optional AnnotationSource::Impl::getAttribution() const { return {}; } +bool AnnotationSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || !std::strcmp(info->type, "fill"); +} + } // namespace mbgl diff --git a/src/mbgl/annotation/annotation_source.hpp b/src/mbgl/annotation/annotation_source.hpp index 018e2136ea..0379426b3e 100644 --- a/src/mbgl/annotation/annotation_source.hpp +++ b/src/mbgl/annotation/annotation_source.hpp @@ -12,13 +12,12 @@ public: class Impl; const Impl& impl() const; +private: + void loadDescription(FileSource&) final; + bool supportsLayerType(const mbgl::style::LayerTypeInfo*) const override; mapbox::base::WeakPtr makeWeakPtr() override { return weakFactory.makeWeakPtr(); } - -private: - void loadDescription(FileSource&) final; - Mutable mutableImpl() const; mapbox::base::WeakPtrFactory weakFactory {this}; }; diff --git a/src/mbgl/style/sources/custom_geometry_source.cpp b/src/mbgl/style/sources/custom_geometry_source.cpp index 73675c056f..5576277de8 100644 --- a/src/mbgl/style/sources/custom_geometry_source.cpp +++ b/src/mbgl/style/sources/custom_geometry_source.cpp @@ -1,12 +1,14 @@ -#include -#include -#include -#include +#include +#include #include #include +#include +#include +#include +#include +#include #include #include -#include namespace mbgl { namespace style { @@ -29,6 +31,12 @@ void CustomGeometrySource::loadDescription(FileSource&) { observer->onSourceLoaded(*this); } +bool CustomGeometrySource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || + !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || + !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); +} + void CustomGeometrySource::setTileData(const CanonicalTileID& tileID, const GeoJSON& data) { loader->self().invoke(&CustomTileLoader::setTileData, tileID, data); diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp index 72a51e212f..b1a5dd981a 100644 --- a/src/mbgl/style/sources/geojson_source.cpp +++ b/src/mbgl/style/sources/geojson_source.cpp @@ -1,9 +1,10 @@ +#include +#include +#include +#include +#include #include #include -#include -#include -#include -#include #include namespace mbgl { @@ -78,5 +79,11 @@ void GeoJSONSource::loadDescription(FileSource& fileSource) { }); } +bool GeoJSONSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || + !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || + !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); +} + } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp index fa268da0ef..abd01af701 100644 --- a/src/mbgl/style/sources/image_source.cpp +++ b/src/mbgl/style/sources/image_source.cpp @@ -1,9 +1,10 @@ +#include +#include +#include #include #include #include -#include #include -#include namespace mbgl { namespace style { @@ -80,5 +81,9 @@ void ImageSource::loadDescription(FileSource& fileSource) { }); } +bool ImageSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "raster"); +} + } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/sources/raster_dem_source.cpp b/src/mbgl/style/sources/raster_dem_source.cpp index bb745561b1..724a322917 100644 --- a/src/mbgl/style/sources/raster_dem_source.cpp +++ b/src/mbgl/style/sources/raster_dem_source.cpp @@ -1,8 +1,9 @@ -#include -#include -#include #include #include +#include +#include +#include +#include #include namespace mbgl { @@ -12,5 +13,9 @@ RasterDEMSource::RasterDEMSource(std::string id, variant u : RasterSource(std::move(id), urlOrTileset_, tileSize, SourceType::RasterDEM){ } +bool RasterDEMSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "hillshade"); +} + } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/sources/raster_source.cpp b/src/mbgl/style/sources/raster_source.cpp index 115887d004..c758a7bc8b 100644 --- a/src/mbgl/style/sources/raster_source.cpp +++ b/src/mbgl/style/sources/raster_source.cpp @@ -1,11 +1,12 @@ -#include -#include -#include +#include #include #include -#include -#include +#include +#include +#include +#include #include +#include namespace mbgl { namespace style { @@ -80,5 +81,9 @@ void RasterSource::loadDescription(FileSource& fileSource) { }); } +bool RasterSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "raster"); +} + } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/sources/vector_source.cpp b/src/mbgl/style/sources/vector_source.cpp index a69ff632d8..7cb89a9474 100644 --- a/src/mbgl/style/sources/vector_source.cpp +++ b/src/mbgl/style/sources/vector_source.cpp @@ -1,12 +1,13 @@ -#include -#include -#include +#include #include #include -#include -#include +#include +#include +#include +#include #include #include +#include namespace mbgl { namespace style { @@ -84,5 +85,11 @@ void VectorSource::loadDescription(FileSource& fileSource) { }); } +bool VectorSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { + return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || + !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || + !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); +} + } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_impl.cpp b/src/mbgl/style/style_impl.cpp index d3298c5cac..95a39819fc 100644 --- a/src/mbgl/style/style_impl.cpp +++ b/src/mbgl/style/style_impl.cpp @@ -1,26 +1,27 @@ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include -#include +#include +#include #include +#include #include +#include #include -#include #include -#include -#include +#include +#include #include +#include +#include #include -#include #include -#include #include -#include -#include -#include +#include +#include namespace mbgl { namespace style { @@ -177,6 +178,15 @@ Layer* Style::Impl::getLayer(const std::string& id) const { Layer* Style::Impl::addLayer(std::unique_ptr layer, optional before) { // TODO: verify source + if (Source* source = sources.get(layer->getSourceID())) { + if (!source->supportsLayerType(layer->baseImpl->getTypeInfo())) { + std::ostringstream message; + message << "Layer '" << layer->getID() << "' is not compatible with source '" << layer->getSourceID() + << "'"; + + throw std::runtime_error(message.str()); + } + } if (layers.get(layer->getID())) { throw std::runtime_error(std::string{"Layer "} + layer->getID() + " already exists"); -- cgit v1.2.1 From 152d4c35fc5c7f06940b820790474fa5d5767112 Mon Sep 17 00:00:00 2001 From: Mikhail Pozdnyakov Date: Wed, 18 Sep 2019 14:31:03 +0300 Subject: [core] Add LayerTypeInfo::TileKind --- src/mbgl/style/layer.cpp | 5 +++++ src/mbgl/style/layers/background_layer.cpp | 3 ++- src/mbgl/style/layers/circle_layer.cpp | 3 ++- src/mbgl/style/layers/custom_layer.cpp | 3 ++- src/mbgl/style/layers/fill_extrusion_layer.cpp | 3 ++- src/mbgl/style/layers/fill_layer.cpp | 3 ++- src/mbgl/style/layers/heatmap_layer.cpp | 3 ++- src/mbgl/style/layers/hillshade_layer.cpp | 3 ++- src/mbgl/style/layers/layer.cpp.ejs | 30 +++++++++++++++++++------- src/mbgl/style/layers/line_layer.cpp | 3 ++- src/mbgl/style/layers/raster_layer.cpp | 3 ++- src/mbgl/style/layers/symbol_layer.cpp | 3 ++- 12 files changed, 47 insertions(+), 18 deletions(-) (limited to 'src') diff --git a/src/mbgl/style/layer.cpp b/src/mbgl/style/layer.cpp index 328cd47555..2f4d50cd83 100644 --- a/src/mbgl/style/layer.cpp +++ b/src/mbgl/style/layer.cpp @@ -4,12 +4,17 @@ #include #include #include +#include #include namespace mbgl { namespace style { +static_assert(mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(LayerTypeInfo::TileKind::Geometry), "tile kind error"); +static_assert(mbgl::underlying_type(Tile::Kind::Raster) == mbgl::underlying_type(LayerTypeInfo::TileKind::Raster), "tile kind error"); +static_assert(mbgl::underlying_type(Tile::Kind::RasterDEM) == mbgl::underlying_type(LayerTypeInfo::TileKind::RasterDEM), "tile kind error"); + static LayerObserver nullObserver; Layer::Layer(Immutable impl) diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp index 1693c47204..f91d8f8493 100644 --- a/src/mbgl/style/layers/background_layer.cpp +++ b/src/mbgl/style/layers/background_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* BackgroundLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::NotRequired }; return &typeInfo; } diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp index 2293ed222e..aba6b897b1 100644 --- a/src/mbgl/style/layers/circle_layer.cpp +++ b/src/mbgl/style/layers/circle_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* CircleLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } diff --git a/src/mbgl/style/layers/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp index e77d6590f7..7e58b8e4e1 100644 --- a/src/mbgl/style/layers/custom_layer.cpp +++ b/src/mbgl/style/layers/custom_layer.cpp @@ -14,7 +14,8 @@ namespace { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired }; + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::NotRequired }; } // namespace CustomLayer::CustomLayer(const std::string& layerID, diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp index 50e32cf812..5214b275fb 100644 --- a/src/mbgl/style/layers/fill_extrusion_layer.cpp +++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* FillExtrusionLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::Required, LayerTypeInfo::Layout::Required, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp index e08c8f3962..63371b34f0 100644 --- a/src/mbgl/style/layers/fill_layer.cpp +++ b/src/mbgl/style/layers/fill_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* FillLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::Required, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } diff --git a/src/mbgl/style/layers/heatmap_layer.cpp b/src/mbgl/style/layers/heatmap_layer.cpp index cb99f76a51..da4f6a35a4 100644 --- a/src/mbgl/style/layers/heatmap_layer.cpp +++ b/src/mbgl/style/layers/heatmap_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* HeatmapLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::Required, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } diff --git a/src/mbgl/style/layers/hillshade_layer.cpp b/src/mbgl/style/layers/hillshade_layer.cpp index 95a395ef25..e96e0f1839 100644 --- a/src/mbgl/style/layers/hillshade_layer.cpp +++ b/src/mbgl/style/layers/hillshade_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* HillshadeLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::Required, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::RasterDEM }; return &typeInfo; } diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs index da34565461..c63999ca32 100644 --- a/src/mbgl/style/layers/layer.cpp.ejs +++ b/src/mbgl/style/layers/layer.cpp.ejs @@ -27,13 +27,20 @@ let defaults = { caps: { 'Source': 'NotRequired', 'Pass3D': 'NotRequired', 'Layout': 'NotRequired', 'FadingTiles': 'NotRequired', - 'CrossTileIndex': 'NotRequired' + 'CrossTileIndex': 'NotRequired', + 'TileKind' : 'NotRequired' }, require: function(cap) { - let copy = Object.assign({}, this); - copy.caps = Object.assign({}, this.caps); - copy.caps[cap] = 'Required'; - return copy; + let copy = Object.assign({}, this); + copy.caps = Object.assign({}, this.caps); + copy.caps[cap] = 'Required'; + return copy; + }, + set: function(cap, value) { + let copy = Object.assign({}, this); + copy.caps = Object.assign({}, this.caps); + copy.caps[cap] = value; + return copy; }, finalize: function() { return Object.keys(this.caps).reduce((acc, key) => { @@ -46,23 +53,30 @@ let defaults = { caps: { 'Source': 'NotRequired', layerCapabilities['background'] = defaults.finalize(); layerCapabilities['fill'] = defaults.require('Source') .require('Layout') + .set('TileKind', 'Geometry') .finalize(); layerCapabilities['fill-extrusion'] = defaults.require('Source') .require('Pass3D') .require('Layout') + .set('TileKind', 'Geometry') .finalize(); layerCapabilities['hillshade'] = defaults.require('Source') .require('Pass3D') + .set('TileKind', 'RasterDEM') .finalize(); layerCapabilities['symbol'] = defaults.require('Source') .require('Layout') .require('FadingTiles') .require('CrossTileIndex') + .set('TileKind', 'Geometry') .finalize(); -layerCapabilities['circle'] = defaults.require('Source').finalize(); +layerCapabilities['circle'] = defaults.require('Source').set('TileKind', 'Geometry').finalize(); layerCapabilities['line'] = layerCapabilities['fill']; -layerCapabilities['heatmap'] = layerCapabilities['hillshade']; -layerCapabilities['raster'] = layerCapabilities['circle']; +layerCapabilities['heatmap'] = defaults.require('Source') + .require('Pass3D') + .set('TileKind', 'Geometry') + .finalize(); +layerCapabilities['raster'] = defaults.require('Source').set('TileKind', 'Raster').finalize(); %> // static const LayerTypeInfo* <%- camelize(type) %>Layer::Impl::staticTypeInfo() noexcept { diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp index deb85cad66..f376765085 100644 --- a/src/mbgl/style/layers/line_layer.cpp +++ b/src/mbgl/style/layers/line_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* LineLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::Required, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp index ead2223ea6..a98919b24a 100644 --- a/src/mbgl/style/layers/raster_layer.cpp +++ b/src/mbgl/style/layers/raster_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* RasterLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::NotRequired, LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Raster }; return &typeInfo; } diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp index 157d8c745f..fbf7c1e958 100644 --- a/src/mbgl/style/layers/symbol_layer.cpp +++ b/src/mbgl/style/layers/symbol_layer.cpp @@ -25,7 +25,8 @@ const LayerTypeInfo* SymbolLayer::Impl::staticTypeInfo() noexcept { LayerTypeInfo::Pass3D::NotRequired, LayerTypeInfo::Layout::Required, LayerTypeInfo::FadingTiles::Required, - LayerTypeInfo::CrossTileIndex::Required + LayerTypeInfo::CrossTileIndex::Required, + LayerTypeInfo::TileKind::Geometry }; return &typeInfo; } -- cgit v1.2.1 From e3137d86d2d873bf0894c438a51510575d7ecc7a Mon Sep 17 00:00:00 2001 From: Mikhail Pozdnyakov Date: Wed, 18 Sep 2019 14:56:21 +0300 Subject: [core] Use LayerInfo::tileKind in sources --- src/mbgl/style/sources/custom_geometry_source.cpp | 5 ++--- src/mbgl/style/sources/geojson_source.cpp | 5 ++--- src/mbgl/style/sources/image_source.cpp | 3 ++- src/mbgl/style/sources/raster_dem_source.cpp | 3 ++- src/mbgl/style/sources/raster_source.cpp | 3 ++- src/mbgl/style/sources/vector_source.cpp | 5 ++--- 6 files changed, 12 insertions(+), 12 deletions(-) (limited to 'src') diff --git a/src/mbgl/style/sources/custom_geometry_source.cpp b/src/mbgl/style/sources/custom_geometry_source.cpp index 5576277de8..1076cbf417 100644 --- a/src/mbgl/style/sources/custom_geometry_source.cpp +++ b/src/mbgl/style/sources/custom_geometry_source.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -32,9 +33,7 @@ void CustomGeometrySource::loadDescription(FileSource&) { } bool CustomGeometrySource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || - !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || - !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); + return mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(info->tileKind); } void CustomGeometrySource::setTileData(const CanonicalTileID& tileID, diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp index b1a5dd981a..baf76d8224 100644 --- a/src/mbgl/style/sources/geojson_source.cpp +++ b/src/mbgl/style/sources/geojson_source.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include namespace mbgl { @@ -80,9 +81,7 @@ void GeoJSONSource::loadDescription(FileSource& fileSource) { } bool GeoJSONSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || - !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || - !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); + return mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(info->tileKind); } } // namespace style diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp index abd01af701..baadc86e7c 100644 --- a/src/mbgl/style/sources/image_source.cpp +++ b/src/mbgl/style/sources/image_source.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -82,7 +83,7 @@ void ImageSource::loadDescription(FileSource& fileSource) { } bool ImageSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "raster"); + return mbgl::underlying_type(Tile::Kind::Raster) == mbgl::underlying_type(info->tileKind); } } // namespace style diff --git a/src/mbgl/style/sources/raster_dem_source.cpp b/src/mbgl/style/sources/raster_dem_source.cpp index 724a322917..dd859cc6d1 100644 --- a/src/mbgl/style/sources/raster_dem_source.cpp +++ b/src/mbgl/style/sources/raster_dem_source.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include namespace mbgl { @@ -14,7 +15,7 @@ RasterDEMSource::RasterDEMSource(std::string id, variant u } bool RasterDEMSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "hillshade"); + return mbgl::underlying_type(Tile::Kind::RasterDEM) == mbgl::underlying_type(info->tileKind); } } // namespace style diff --git a/src/mbgl/style/sources/raster_source.cpp b/src/mbgl/style/sources/raster_source.cpp index c758a7bc8b..851f32573e 100644 --- a/src/mbgl/style/sources/raster_source.cpp +++ b/src/mbgl/style/sources/raster_source.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include @@ -82,7 +83,7 @@ void RasterSource::loadDescription(FileSource& fileSource) { } bool RasterSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "raster"); + return mbgl::underlying_type(Tile::Kind::Raster) == mbgl::underlying_type(info->tileKind); } } // namespace style diff --git a/src/mbgl/style/sources/vector_source.cpp b/src/mbgl/style/sources/vector_source.cpp index 7cb89a9474..dc1a45fdff 100644 --- a/src/mbgl/style/sources/vector_source.cpp +++ b/src/mbgl/style/sources/vector_source.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -86,9 +87,7 @@ void VectorSource::loadDescription(FileSource& fileSource) { } bool VectorSource::supportsLayerType(const mbgl::style::LayerTypeInfo* info) const { - return !std::strcmp(info->type, "line") || !std::strcmp(info->type, "symbol") || - !std::strcmp(info->type, "circle") || !std::strcmp(info->type, "fill") || - !std::strcmp(info->type, "fill-extrusion") || !std::strcmp(info->type, "heatmap"); + return mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(info->tileKind); } } // namespace style -- cgit v1.2.1 From 30e659beed5a5dcb286df79280620bc799086523 Mon Sep 17 00:00:00 2001 From: Mikhail Pozdnyakov Date: Wed, 18 Sep 2019 15:11:05 +0300 Subject: [core] Fix formatting --- src/mbgl/style/layer.cpp | 15 +++++++++------ src/mbgl/style/layers/background_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/circle_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/custom_layer.cpp | 15 +++++++-------- src/mbgl/style/layers/fill_extrusion_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/fill_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/heatmap_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/hillshade_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/layer.cpp.ejs | 6 ++---- src/mbgl/style/layers/line_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/raster_layer.cpp | 16 +++++++--------- src/mbgl/style/layers/symbol_layer.cpp | 16 +++++++--------- 12 files changed, 81 insertions(+), 99 deletions(-) (limited to 'src') diff --git a/src/mbgl/style/layer.cpp b/src/mbgl/style/layer.cpp index 2f4d50cd83..04a897022c 100644 --- a/src/mbgl/style/layer.cpp +++ b/src/mbgl/style/layer.cpp @@ -1,9 +1,9 @@ -#include -#include -#include #include #include #include +#include +#include +#include #include #include @@ -11,9 +11,12 @@ namespace mbgl { namespace style { -static_assert(mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(LayerTypeInfo::TileKind::Geometry), "tile kind error"); -static_assert(mbgl::underlying_type(Tile::Kind::Raster) == mbgl::underlying_type(LayerTypeInfo::TileKind::Raster), "tile kind error"); -static_assert(mbgl::underlying_type(Tile::Kind::RasterDEM) == mbgl::underlying_type(LayerTypeInfo::TileKind::RasterDEM), "tile kind error"); +static_assert(mbgl::underlying_type(Tile::Kind::Geometry) == mbgl::underlying_type(LayerTypeInfo::TileKind::Geometry), + "tile kind error"); +static_assert(mbgl::underlying_type(Tile::Kind::Raster) == mbgl::underlying_type(LayerTypeInfo::TileKind::Raster), + "tile kind error"); +static_assert(mbgl::underlying_type(Tile::Kind::RasterDEM) == mbgl::underlying_type(LayerTypeInfo::TileKind::RasterDEM), + "tile kind error"); static LayerObserver nullObserver; diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp index f91d8f8493..2b33b0b3d0 100644 --- a/src/mbgl/style/layers/background_layer.cpp +++ b/src/mbgl/style/layers/background_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* BackgroundLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"background", - LayerTypeInfo::Source::NotRequired, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::NotRequired - }; + const static LayerTypeInfo typeInfo{"background", + LayerTypeInfo::Source::NotRequired, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::NotRequired}; return &typeInfo; } diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp index aba6b897b1..baabe5c8bf 100644 --- a/src/mbgl/style/layers/circle_layer.cpp +++ b/src/mbgl/style/layers/circle_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* CircleLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"circle", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"circle", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } diff --git a/src/mbgl/style/layers/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp index 7e58b8e4e1..8b9e17ea25 100644 --- a/src/mbgl/style/layers/custom_layer.cpp +++ b/src/mbgl/style/layers/custom_layer.cpp @@ -8,14 +8,13 @@ namespace mbgl { namespace style { namespace { - const LayerTypeInfo typeInfoCustom - { "", - LayerTypeInfo::Source::NotRequired, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::NotRequired }; +const LayerTypeInfo typeInfoCustom{"", + LayerTypeInfo::Source::NotRequired, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::NotRequired}; } // namespace CustomLayer::CustomLayer(const std::string& layerID, diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp index 5214b275fb..b22f0a3075 100644 --- a/src/mbgl/style/layers/fill_extrusion_layer.cpp +++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* FillExtrusionLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"fill-extrusion", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::Required, - LayerTypeInfo::Layout::Required, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"fill-extrusion", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::Required, + LayerTypeInfo::Layout::Required, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp index 63371b34f0..2c3ee42fae 100644 --- a/src/mbgl/style/layers/fill_layer.cpp +++ b/src/mbgl/style/layers/fill_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* FillLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"fill", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::Required, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"fill", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::Required, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } diff --git a/src/mbgl/style/layers/heatmap_layer.cpp b/src/mbgl/style/layers/heatmap_layer.cpp index da4f6a35a4..a3cedd3747 100644 --- a/src/mbgl/style/layers/heatmap_layer.cpp +++ b/src/mbgl/style/layers/heatmap_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* HeatmapLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"heatmap", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::Required, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"heatmap", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::Required, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } diff --git a/src/mbgl/style/layers/hillshade_layer.cpp b/src/mbgl/style/layers/hillshade_layer.cpp index e96e0f1839..05dd009d25 100644 --- a/src/mbgl/style/layers/hillshade_layer.cpp +++ b/src/mbgl/style/layers/hillshade_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* HillshadeLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"hillshade", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::Required, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::RasterDEM - }; + const static LayerTypeInfo typeInfo{"hillshade", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::Required, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::RasterDEM}; return &typeInfo; } diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs index c63999ca32..eee2d0583e 100644 --- a/src/mbgl/style/layers/layer.cpp.ejs +++ b/src/mbgl/style/layers/layer.cpp.ejs @@ -80,10 +80,8 @@ layerCapabilities['raster'] = defaults.require('Source').set('TileKind', %> // static const LayerTypeInfo* <%- camelize(type) %>Layer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"<%- type %>", - <%-`${layerCapabilities[type].map(cap => `LayerTypeInfo::${cap}`).join(',\n ')}` %> - }; + const static LayerTypeInfo typeInfo{"<%- type %>", + <%-`${layerCapabilities[type].map(cap => `LayerTypeInfo::${cap}`).join(',\n ')}` %>}; return &typeInfo; } diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp index f376765085..c148a66407 100644 --- a/src/mbgl/style/layers/line_layer.cpp +++ b/src/mbgl/style/layers/line_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* LineLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"line", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::Required, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"line", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::Required, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp index a98919b24a..b85d031938 100644 --- a/src/mbgl/style/layers/raster_layer.cpp +++ b/src/mbgl/style/layers/raster_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* RasterLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"raster", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::NotRequired, - LayerTypeInfo::FadingTiles::NotRequired, - LayerTypeInfo::CrossTileIndex::NotRequired, - LayerTypeInfo::TileKind::Raster - }; + const static LayerTypeInfo typeInfo{"raster", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::NotRequired, + LayerTypeInfo::FadingTiles::NotRequired, + LayerTypeInfo::CrossTileIndex::NotRequired, + LayerTypeInfo::TileKind::Raster}; return &typeInfo; } diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp index fbf7c1e958..35d75686af 100644 --- a/src/mbgl/style/layers/symbol_layer.cpp +++ b/src/mbgl/style/layers/symbol_layer.cpp @@ -19,15 +19,13 @@ namespace style { // static const LayerTypeInfo* SymbolLayer::Impl::staticTypeInfo() noexcept { - const static LayerTypeInfo typeInfo - {"symbol", - LayerTypeInfo::Source::Required, - LayerTypeInfo::Pass3D::NotRequired, - LayerTypeInfo::Layout::Required, - LayerTypeInfo::FadingTiles::Required, - LayerTypeInfo::CrossTileIndex::Required, - LayerTypeInfo::TileKind::Geometry - }; + const static LayerTypeInfo typeInfo{"symbol", + LayerTypeInfo::Source::Required, + LayerTypeInfo::Pass3D::NotRequired, + LayerTypeInfo::Layout::Required, + LayerTypeInfo::FadingTiles::Required, + LayerTypeInfo::CrossTileIndex::Required, + LayerTypeInfo::TileKind::Geometry}; return &typeInfo; } -- cgit v1.2.1