diff options
Diffstat (limited to 'src/mbgl/style/layers')
25 files changed, 312 insertions, 722 deletions
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp index e2a517b9f4..b4ffea138b 100644 --- a/src/mbgl/style/layers/background_layer.cpp +++ b/src/mbgl/style/layers/background_layer.cpp @@ -8,13 +8,13 @@ namespace mbgl { namespace style { BackgroundLayer::BackgroundLayer(const std::string& layerID) - : Layer(Type::Background, std::make_unique<Impl>()) + : Layer(LayerType::Background, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; } BackgroundLayer::BackgroundLayer(const Impl& other) - : Layer(Type::Background, std::make_unique<Impl>(other)) + : Layer(LayerType::Background, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -27,7 +27,7 @@ std::unique_ptr<Layer> BackgroundLayer::Impl::clone() const { std::unique_ptr<Layer> BackgroundLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<BackgroundLayer>(*this); result->impl->id = id_; - result->impl->paint = BackgroundPaintProperties(); + result->impl->cascading = BackgroundPaintProperties::Cascading(); return std::move(result); } @@ -45,22 +45,22 @@ PropertyValue<Color> BackgroundLayer::getDefaultBackgroundColor() { } PropertyValue<Color> BackgroundLayer::getBackgroundColor(const optional<std::string>& klass) const { - return impl->paint.get<BackgroundColor>(klass); + return impl->cascading.template get<BackgroundColor>().get(klass); } void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) { if (value == getBackgroundColor(klass)) return; - impl->paint.set<BackgroundColor>(value, klass); + impl->cascading.template get<BackgroundColor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<BackgroundColor>(value, klass); + impl->cascading.template get<BackgroundColor>().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<BackgroundColor>(klass); + return impl->cascading.template get<BackgroundColor>().getTransition(klass); } PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() { @@ -68,22 +68,22 @@ PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() { } PropertyValue<std::string> BackgroundLayer::getBackgroundPattern(const optional<std::string>& klass) const { - return impl->paint.get<BackgroundPattern>(klass); + return impl->cascading.template get<BackgroundPattern>().get(klass); } void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) { if (value == getBackgroundPattern(klass)) return; - impl->paint.set<BackgroundPattern>(value, klass); + impl->cascading.template get<BackgroundPattern>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<BackgroundPattern>(value, klass); + impl->cascading.template get<BackgroundPattern>().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundPatternTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<BackgroundPattern>(klass); + return impl->cascading.template get<BackgroundPattern>().getTransition(klass); } PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() { @@ -91,22 +91,22 @@ PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() { } PropertyValue<float> BackgroundLayer::getBackgroundOpacity(const optional<std::string>& klass) const { - return impl->paint.get<BackgroundOpacity>(klass); + return impl->cascading.template get<BackgroundOpacity>().get(klass); } void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getBackgroundOpacity(klass)) return; - impl->paint.set<BackgroundOpacity>(value, klass); + impl->cascading.template get<BackgroundOpacity>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<BackgroundOpacity>(value, klass); + impl->cascading.template get<BackgroundOpacity>().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<BackgroundOpacity>(klass); + return impl->cascading.template get<BackgroundOpacity>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/background_layer_impl.cpp b/src/mbgl/style/layers/background_layer_impl.cpp index f25ba9cfb4..6c4a4c26d9 100644 --- a/src/mbgl/style/layers/background_layer_impl.cpp +++ b/src/mbgl/style/layers/background_layer_impl.cpp @@ -1,24 +1,11 @@ #include <mbgl/style/layers/background_layer_impl.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/render_background_layer.hpp> namespace mbgl { namespace style { -void BackgroundLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool BackgroundLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - paint.evaluate(parameters); - - passes = paint.evaluated.get<BackgroundOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> BackgroundLayer::Impl::createBucket(const BucketParameters&, const std::vector<const Layer*>&) const { - assert(false); - return nullptr; +std::unique_ptr<RenderLayer> BackgroundLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderBackgroundLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp index 02a8c423d6..85152da4ec 100644 --- a/src/mbgl/style/layers/background_layer_impl.hpp +++ b/src/mbgl/style/layers/background_layer_impl.hpp @@ -13,12 +13,9 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - - BackgroundPaintProperties paint; + BackgroundPaintProperties::Cascading cascading; }; } // namespace style diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp index a628d7a417..8b3431a9a1 100644 --- a/src/mbgl/style/layers/circle_layer.cpp +++ b/src/mbgl/style/layers/circle_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { CircleLayer::CircleLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::Circle, std::make_unique<Impl>()) + : Layer(LayerType::Circle, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } CircleLayer::CircleLayer(const Impl& other) - : Layer(Type::Circle, std::make_unique<Impl>(other)) + : Layer(LayerType::Circle, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> CircleLayer::Impl::clone() const { std::unique_ptr<Layer> CircleLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<CircleLayer>(*this); result->impl->id = id_; - result->impl->paint = CirclePaintProperties(); + result->impl->cascading = CirclePaintProperties::Cascading(); return std::move(result); } @@ -70,13 +70,13 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleRadius() { } DataDrivenPropertyValue<float> CircleLayer::getCircleRadius(const optional<std::string>& klass) const { - return impl->paint.get<CircleRadius>(klass); + return impl->cascading.template get<CircleRadius>().get(klass); } void CircleLayer::setCircleRadius(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getCircleRadius(klass)) return; - impl->paint.set<CircleRadius>(value, klass); + impl->cascading.template get<CircleRadius>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -85,11 +85,11 @@ void CircleLayer::setCircleRadius(DataDrivenPropertyValue<float> value, const op } void CircleLayer::setCircleRadiusTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleRadius>(value, klass); + impl->cascading.template get<CircleRadius>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleRadiusTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleRadius>(klass); + return impl->cascading.template get<CircleRadius>().getTransition(klass); } DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() { @@ -97,13 +97,13 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() { } DataDrivenPropertyValue<Color> CircleLayer::getCircleColor(const optional<std::string>& klass) const { - return impl->paint.get<CircleColor>(klass); + return impl->cascading.template get<CircleColor>().get(klass); } void CircleLayer::setCircleColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getCircleColor(klass)) return; - impl->paint.set<CircleColor>(value, klass); + impl->cascading.template get<CircleColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -112,11 +112,11 @@ void CircleLayer::setCircleColor(DataDrivenPropertyValue<Color> value, const opt } void CircleLayer::setCircleColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleColor>(value, klass); + impl->cascading.template get<CircleColor>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleColor>(klass); + return impl->cascading.template get<CircleColor>().getTransition(klass); } DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() { @@ -124,13 +124,13 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() { } DataDrivenPropertyValue<float> CircleLayer::getCircleBlur(const optional<std::string>& klass) const { - return impl->paint.get<CircleBlur>(klass); + return impl->cascading.template get<CircleBlur>().get(klass); } void CircleLayer::setCircleBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getCircleBlur(klass)) return; - impl->paint.set<CircleBlur>(value, klass); + impl->cascading.template get<CircleBlur>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -139,11 +139,11 @@ void CircleLayer::setCircleBlur(DataDrivenPropertyValue<float> value, const opti } void CircleLayer::setCircleBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleBlur>(value, klass); + impl->cascading.template get<CircleBlur>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleBlurTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleBlur>(klass); + return impl->cascading.template get<CircleBlur>().getTransition(klass); } DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() { @@ -151,13 +151,13 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() { } DataDrivenPropertyValue<float> CircleLayer::getCircleOpacity(const optional<std::string>& klass) const { - return impl->paint.get<CircleOpacity>(klass); + return impl->cascading.template get<CircleOpacity>().get(klass); } void CircleLayer::setCircleOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getCircleOpacity(klass)) return; - impl->paint.set<CircleOpacity>(value, klass); + impl->cascading.template get<CircleOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -166,11 +166,11 @@ void CircleLayer::setCircleOpacity(DataDrivenPropertyValue<float> value, const o } void CircleLayer::setCircleOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleOpacity>(value, klass); + impl->cascading.template get<CircleOpacity>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleOpacity>(klass); + return impl->cascading.template get<CircleOpacity>().getTransition(klass); } PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() { @@ -178,22 +178,22 @@ PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() { } PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate(const optional<std::string>& klass) const { - return impl->paint.get<CircleTranslate>(klass); + return impl->cascading.template get<CircleTranslate>().get(klass); } void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getCircleTranslate(klass)) return; - impl->paint.set<CircleTranslate>(value, klass); + impl->cascading.template get<CircleTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCircleTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleTranslate>(value, klass); + impl->cascading.template get<CircleTranslate>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleTranslate>(klass); + return impl->cascading.template get<CircleTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor() { @@ -201,22 +201,22 @@ PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor( } PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<CircleTranslateAnchor>(klass); + return impl->cascading.template get<CircleTranslateAnchor>().get(klass); } void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getCircleTranslateAnchor(klass)) return; - impl->paint.set<CircleTranslateAnchor>(value, klass); + impl->cascading.template get<CircleTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCircleTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleTranslateAnchor>(value, klass); + impl->cascading.template get<CircleTranslateAnchor>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleTranslateAnchor>(klass); + return impl->cascading.template get<CircleTranslateAnchor>().getTransition(klass); } PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() { @@ -224,22 +224,22 @@ PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() { } PropertyValue<CirclePitchScaleType> CircleLayer::getCirclePitchScale(const optional<std::string>& klass) const { - return impl->paint.get<CirclePitchScale>(klass); + return impl->cascading.template get<CirclePitchScale>().get(klass); } void CircleLayer::setCirclePitchScale(PropertyValue<CirclePitchScaleType> value, const optional<std::string>& klass) { if (value == getCirclePitchScale(klass)) return; - impl->paint.set<CirclePitchScale>(value, klass); + impl->cascading.template get<CirclePitchScale>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCirclePitchScaleTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CirclePitchScale>(value, klass); + impl->cascading.template get<CirclePitchScale>().setTransition(value, klass); } TransitionOptions CircleLayer::getCirclePitchScaleTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CirclePitchScale>(klass); + return impl->cascading.template get<CirclePitchScale>().getTransition(klass); } DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() { @@ -247,13 +247,13 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() { } DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeWidth(const optional<std::string>& klass) const { - return impl->paint.get<CircleStrokeWidth>(klass); + return impl->cascading.template get<CircleStrokeWidth>().get(klass); } void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getCircleStrokeWidth(klass)) return; - impl->paint.set<CircleStrokeWidth>(value, klass); + impl->cascading.template get<CircleStrokeWidth>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -262,11 +262,11 @@ void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue<float> value, con } void CircleLayer::setCircleStrokeWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleStrokeWidth>(value, klass); + impl->cascading.template get<CircleStrokeWidth>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeWidthTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleStrokeWidth>(klass); + return impl->cascading.template get<CircleStrokeWidth>().getTransition(klass); } DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() { @@ -274,13 +274,13 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() { } DataDrivenPropertyValue<Color> CircleLayer::getCircleStrokeColor(const optional<std::string>& klass) const { - return impl->paint.get<CircleStrokeColor>(klass); + return impl->cascading.template get<CircleStrokeColor>().get(klass); } void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getCircleStrokeColor(klass)) return; - impl->paint.set<CircleStrokeColor>(value, klass); + impl->cascading.template get<CircleStrokeColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -289,11 +289,11 @@ void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue<Color> value, con } void CircleLayer::setCircleStrokeColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleStrokeColor>(value, klass); + impl->cascading.template get<CircleStrokeColor>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleStrokeColor>(klass); + return impl->cascading.template get<CircleStrokeColor>().getTransition(klass); } DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() { @@ -301,13 +301,13 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() { } DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeOpacity(const optional<std::string>& klass) const { - return impl->paint.get<CircleStrokeOpacity>(klass); + return impl->cascading.template get<CircleStrokeOpacity>().get(klass); } void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getCircleStrokeOpacity(klass)) return; - impl->paint.set<CircleStrokeOpacity>(value, klass); + impl->cascading.template get<CircleStrokeOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -316,11 +316,11 @@ void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue<float> value, c } void CircleLayer::setCircleStrokeOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<CircleStrokeOpacity>(value, klass); + impl->cascading.template get<CircleStrokeOpacity>().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<CircleStrokeOpacity>(klass); + return impl->cascading.template get<CircleStrokeOpacity>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp index 2dde632f6e..31b286f273 100644 --- a/src/mbgl/style/layers/circle_layer_impl.cpp +++ b/src/mbgl/style/layers/circle_layer_impl.cpp @@ -1,52 +1,11 @@ #include <mbgl/style/layers/circle_layer_impl.hpp> -#include <mbgl/renderer/circle_bucket.hpp> -#include <mbgl/geometry/feature_index.hpp> -#include <mbgl/util/math.hpp> -#include <mbgl/util/intersection_tests.hpp> +#include <mbgl/renderer/render_circle_layer.hpp> namespace mbgl { namespace style { -void CircleLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool CircleLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - paint.evaluate(parameters); - - passes = ((paint.evaluated.get<CircleRadius>().constantOr(1) > 0 || - paint.evaluated.get<CircleStrokeWidth>().constantOr(1) > 0) - && (paint.evaluated.get<CircleColor>().constantOr(Color::black()).a > 0 || - paint.evaluated.get<CircleStrokeColor>().constantOr(Color::black()).a > 0) - && (paint.evaluated.get<CircleOpacity>().constantOr(1) > 0 || - paint.evaluated.get<CircleStrokeOpacity>().constantOr(1) > 0)) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> CircleLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector<const Layer*>& layers) const { - return std::make_unique<CircleBucket>(parameters, layers); -} - -bool CircleLayer::Impl::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float zoom, - const float bearing, - const float pixelsToTileUnits) const { - - // Translate query geometry - auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( - queryGeometry, paint.evaluated.get<CircleTranslate>(), paint.evaluated.get<CircleTranslateAnchor>(), bearing, pixelsToTileUnits); - - // Evaluate function - auto circleRadius = paint.evaluated.get<CircleRadius>() - .evaluate(feature, zoom, CircleRadius::defaultValue()) - * pixelsToTileUnits; - - // Test intersection - return util::polygonIntersectsBufferedMultiPoint(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries(), circleRadius); +std::unique_ptr<RenderLayer> CircleLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderCircleLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp index 2e3f37e1f9..886815f0d1 100644 --- a/src/mbgl/style/layers/circle_layer_impl.hpp +++ b/src/mbgl/style/layers/circle_layer_impl.hpp @@ -13,19 +13,9 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const float, - const float) const override; - - CirclePaintProperties paint; + CirclePaintProperties::Cascading cascading; }; } // namespace style diff --git a/src/mbgl/style/layers/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp index 2504f3f15c..cda8a157f0 100644 --- a/src/mbgl/style/layers/custom_layer.cpp +++ b/src/mbgl/style/layers/custom_layer.cpp @@ -1,5 +1,6 @@ #include <mbgl/style/layers/custom_layer.hpp> #include <mbgl/style/layers/custom_layer_impl.hpp> +#include <mbgl/util/logging.hpp> namespace mbgl { namespace style { @@ -9,12 +10,13 @@ CustomLayer::CustomLayer(const std::string& layerID, CustomLayerRenderFunction render, CustomLayerDeinitializeFunction deinit, void* context) - : Layer(Type::Custom, std::make_unique<Impl>(layerID, init, render, deinit, context)) + : Layer(LayerType::Custom, std::make_unique<Impl>(layerID, init, render, deinit, context)) , impl(static_cast<Impl*>(baseImpl.get())) { + Log::Info(Event::General, "New custom layer: %s", layerID.c_str()); } CustomLayer::CustomLayer(const Impl& other) - : Layer(Type::Custom, std::make_unique<Impl>(other)) + : Layer(LayerType::Custom, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -22,7 +24,7 @@ CustomLayer::~CustomLayer() = default; template <> bool Layer::is<CustomLayer>() const { - return type == Type::Custom; + return type == LayerType::Custom; } } // namespace style diff --git a/src/mbgl/style/layers/custom_layer_impl.cpp b/src/mbgl/style/layers/custom_layer_impl.cpp index 375c9ee27b..1d3e9af8d6 100644 --- a/src/mbgl/style/layers/custom_layer_impl.cpp +++ b/src/mbgl/style/layers/custom_layer_impl.cpp @@ -1,15 +1,20 @@ #include <mbgl/style/layers/custom_layer_impl.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/render_custom_layer.hpp> #include <mbgl/map/transform_state.hpp> - +#include <mbgl/util/logging.hpp> namespace mbgl { namespace style { +std::unique_ptr<RenderLayer> CustomLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderCustomLayer>(*this); +} + CustomLayer::Impl::Impl(const std::string& id_, CustomLayerInitializeFunction initializeFn_, CustomLayerRenderFunction renderFn_, CustomLayerDeinitializeFunction deinitializeFn_, void* context_) { + Log::Info(Event::General, "New custom layer Impl: %s", id_.c_str()); id = id_; initializeFn = initializeFn_; renderFn = renderFn_; @@ -17,8 +22,8 @@ CustomLayer::Impl::Impl(const std::string& id_, context = context_; } -CustomLayer::Impl::Impl(const CustomLayer::Impl& other) - : Layer::Impl(other) { +CustomLayer::Impl::Impl(const CustomLayer::Impl &other) + : Layer::Impl(other) { id = other.id; // Don't copy anything else. } @@ -65,15 +70,5 @@ void CustomLayer::Impl::render(const TransformState& state) const { renderFn(context, parameters); } -bool CustomLayer::Impl::evaluate(const PropertyEvaluationParameters&) { - passes = RenderPass::Translucent; - return false; -} - -std::unique_ptr<Bucket> CustomLayer::Impl::createBucket(const BucketParameters&, const std::vector<const Layer*>&) const { - assert(false); - return nullptr; -} - } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp index 33eb86828c..e612d17f14 100644 --- a/src/mbgl/style/layers/custom_layer_impl.hpp +++ b/src/mbgl/style/layers/custom_layer_impl.hpp @@ -29,10 +29,7 @@ private: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) final {} - bool evaluate(const PropertyEvaluationParameters&) final; - - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const final; + std::unique_ptr<RenderLayer> createRenderLayer() const final; CustomLayerInitializeFunction initializeFn = nullptr; CustomLayerRenderFunction renderFn = nullptr; diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp index 53f7fc0757..6f11d6052c 100644 --- a/src/mbgl/style/layers/fill_extrusion_layer.cpp +++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { FillExtrusionLayer::FillExtrusionLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::FillExtrusion, std::make_unique<Impl>()) + : Layer(LayerType::FillExtrusion, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } FillExtrusionLayer::FillExtrusionLayer(const Impl& other) - : Layer(Type::FillExtrusion, std::make_unique<Impl>(other)) + : Layer(LayerType::FillExtrusion, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> FillExtrusionLayer::Impl::clone() const { std::unique_ptr<Layer> FillExtrusionLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<FillExtrusionLayer>(*this); result->impl->id = id_; - result->impl->paint = FillExtrusionPaintProperties(); + result->impl->cascading = FillExtrusionPaintProperties::Cascading(); return std::move(result); } @@ -70,22 +70,22 @@ PropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionOpacity() { } PropertyValue<float> FillExtrusionLayer::getFillExtrusionOpacity(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionOpacity>(klass); + return impl->cascading.template get<FillExtrusionOpacity>().get(klass); } void FillExtrusionLayer::setFillExtrusionOpacity(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getFillExtrusionOpacity(klass)) return; - impl->paint.set<FillExtrusionOpacity>(value, klass); + impl->cascading.template get<FillExtrusionOpacity>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionOpacity>(value, klass); + impl->cascading.template get<FillExtrusionOpacity>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionOpacity>(klass); + return impl->cascading.template get<FillExtrusionOpacity>().getTransition(klass); } DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor() { @@ -93,13 +93,13 @@ DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor( } DataDrivenPropertyValue<Color> FillExtrusionLayer::getFillExtrusionColor(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionColor>(klass); + return impl->cascading.template get<FillExtrusionColor>().get(klass); } void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getFillExtrusionColor(klass)) return; - impl->paint.set<FillExtrusionColor>(value, klass); + impl->cascading.template get<FillExtrusionColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -108,11 +108,11 @@ void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue<Color> va } void FillExtrusionLayer::setFillExtrusionColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionColor>(value, klass); + impl->cascading.template get<FillExtrusionColor>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionColor>(klass); + return impl->cascading.template get<FillExtrusionColor>().getTransition(klass); } PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionTranslate() { @@ -120,22 +120,22 @@ PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionT } PropertyValue<std::array<float, 2>> FillExtrusionLayer::getFillExtrusionTranslate(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionTranslate>(klass); + return impl->cascading.template get<FillExtrusionTranslate>().get(klass); } void FillExtrusionLayer::setFillExtrusionTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getFillExtrusionTranslate(klass)) return; - impl->paint.set<FillExtrusionTranslate>(value, klass); + impl->cascading.template get<FillExtrusionTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionTranslate>(value, klass); + impl->cascading.template get<FillExtrusionTranslate>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionTranslate>(klass); + return impl->cascading.template get<FillExtrusionTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTranslateAnchor() { @@ -143,22 +143,22 @@ PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTr } PropertyValue<TranslateAnchorType> FillExtrusionLayer::getFillExtrusionTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionTranslateAnchor>(klass); + return impl->cascading.template get<FillExtrusionTranslateAnchor>().get(klass); } void FillExtrusionLayer::setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getFillExtrusionTranslateAnchor(klass)) return; - impl->paint.set<FillExtrusionTranslateAnchor>(value, klass); + impl->cascading.template get<FillExtrusionTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionTranslateAnchor>(value, klass); + impl->cascading.template get<FillExtrusionTranslateAnchor>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionTranslateAnchor>(klass); + return impl->cascading.template get<FillExtrusionTranslateAnchor>().getTransition(klass); } PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern() { @@ -166,22 +166,22 @@ PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern() } PropertyValue<std::string> FillExtrusionLayer::getFillExtrusionPattern(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionPattern>(klass); + return impl->cascading.template get<FillExtrusionPattern>().get(klass); } void FillExtrusionLayer::setFillExtrusionPattern(PropertyValue<std::string> value, const optional<std::string>& klass) { if (value == getFillExtrusionPattern(klass)) return; - impl->paint.set<FillExtrusionPattern>(value, klass); + impl->cascading.template get<FillExtrusionPattern>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionPattern>(value, klass); + impl->cascading.template get<FillExtrusionPattern>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionPatternTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionPattern>(klass); + return impl->cascading.template get<FillExtrusionPattern>().getTransition(klass); } DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight() { @@ -189,13 +189,13 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight } DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionHeight(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionHeight>(klass); + return impl->cascading.template get<FillExtrusionHeight>().get(klass); } void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getFillExtrusionHeight(klass)) return; - impl->paint.set<FillExtrusionHeight>(value, klass); + impl->cascading.template get<FillExtrusionHeight>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -204,11 +204,11 @@ void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue<float> v } void FillExtrusionLayer::setFillExtrusionHeightTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionHeight>(value, klass); + impl->cascading.template get<FillExtrusionHeight>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionHeightTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionHeight>(klass); + return impl->cascading.template get<FillExtrusionHeight>().getTransition(klass); } DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() { @@ -216,13 +216,13 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() } DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionBase(const optional<std::string>& klass) const { - return impl->paint.get<FillExtrusionBase>(klass); + return impl->cascading.template get<FillExtrusionBase>().get(klass); } void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getFillExtrusionBase(klass)) return; - impl->paint.set<FillExtrusionBase>(value, klass); + impl->cascading.template get<FillExtrusionBase>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -231,11 +231,11 @@ void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue<float> val } void FillExtrusionLayer::setFillExtrusionBaseTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillExtrusionBase>(value, klass); + impl->cascading.template get<FillExtrusionBase>().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillExtrusionBase>(klass); + return impl->cascading.template get<FillExtrusionBase>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp b/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp index a809820644..5340541221 100644 --- a/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp +++ b/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp @@ -1,18 +1,11 @@ #include <mbgl/style/layers/fill_extrusion_layer_impl.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/render_fill_extrusion_layer.hpp> namespace mbgl { namespace style { -void FillExtrusionLayer::Impl::cascade(const CascadeParameters&) { -} - -bool FillExtrusionLayer::Impl::evaluate(const PropertyEvaluationParameters&) { - return false; -} - -std::unique_ptr<Bucket> FillExtrusionLayer::Impl::createBucket(const BucketParameters&, const std::vector<const Layer*>&) const { - return nullptr; +std::unique_ptr<RenderLayer> FillExtrusionLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderFillExtrusionLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp b/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp index ed7ef747fb..f6f9753460 100644 --- a/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp +++ b/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp @@ -13,12 +13,11 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; + FillExtrusionPaintProperties::Cascading cascading; - FillExtrusionPaintProperties paint; + //style::FillExtrusionLayer::Impl* const impl; }; } // namespace style diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp index 34203a10c0..9fd9d33af3 100644 --- a/src/mbgl/style/layers/fill_layer.cpp +++ b/src/mbgl/style/layers/fill_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { FillLayer::FillLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::Fill, std::make_unique<Impl>()) + : Layer(LayerType::Fill, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } FillLayer::FillLayer(const Impl& other) - : Layer(Type::Fill, std::make_unique<Impl>(other)) + : Layer(LayerType::Fill, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> FillLayer::Impl::clone() const { std::unique_ptr<Layer> FillLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<FillLayer>(*this); result->impl->id = id_; - result->impl->paint = FillPaintProperties(); + result->impl->cascading = FillPaintProperties::Cascading(); return std::move(result); } @@ -70,22 +70,22 @@ PropertyValue<bool> FillLayer::getDefaultFillAntialias() { } PropertyValue<bool> FillLayer::getFillAntialias(const optional<std::string>& klass) const { - return impl->paint.get<FillAntialias>(klass); + return impl->cascading.template get<FillAntialias>().get(klass); } void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) { if (value == getFillAntialias(klass)) return; - impl->paint.set<FillAntialias>(value, klass); + impl->cascading.template get<FillAntialias>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillAntialiasTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillAntialias>(value, klass); + impl->cascading.template get<FillAntialias>().setTransition(value, klass); } TransitionOptions FillLayer::getFillAntialiasTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillAntialias>(klass); + return impl->cascading.template get<FillAntialias>().getTransition(klass); } DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() { @@ -93,13 +93,13 @@ DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() { } DataDrivenPropertyValue<float> FillLayer::getFillOpacity(const optional<std::string>& klass) const { - return impl->paint.get<FillOpacity>(klass); + return impl->cascading.template get<FillOpacity>().get(klass); } void FillLayer::setFillOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getFillOpacity(klass)) return; - impl->paint.set<FillOpacity>(value, klass); + impl->cascading.template get<FillOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -108,11 +108,11 @@ void FillLayer::setFillOpacity(DataDrivenPropertyValue<float> value, const optio } void FillLayer::setFillOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillOpacity>(value, klass); + impl->cascading.template get<FillOpacity>().setTransition(value, klass); } TransitionOptions FillLayer::getFillOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillOpacity>(klass); + return impl->cascading.template get<FillOpacity>().getTransition(klass); } DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() { @@ -120,13 +120,13 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() { } DataDrivenPropertyValue<Color> FillLayer::getFillColor(const optional<std::string>& klass) const { - return impl->paint.get<FillColor>(klass); + return impl->cascading.template get<FillColor>().get(klass); } void FillLayer::setFillColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getFillColor(klass)) return; - impl->paint.set<FillColor>(value, klass); + impl->cascading.template get<FillColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -135,11 +135,11 @@ void FillLayer::setFillColor(DataDrivenPropertyValue<Color> value, const optiona } void FillLayer::setFillColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillColor>(value, klass); + impl->cascading.template get<FillColor>().setTransition(value, klass); } TransitionOptions FillLayer::getFillColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillColor>(klass); + return impl->cascading.template get<FillColor>().getTransition(klass); } DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() { @@ -147,13 +147,13 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() { } DataDrivenPropertyValue<Color> FillLayer::getFillOutlineColor(const optional<std::string>& klass) const { - return impl->paint.get<FillOutlineColor>(klass); + return impl->cascading.template get<FillOutlineColor>().get(klass); } void FillLayer::setFillOutlineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getFillOutlineColor(klass)) return; - impl->paint.set<FillOutlineColor>(value, klass); + impl->cascading.template get<FillOutlineColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -162,11 +162,11 @@ void FillLayer::setFillOutlineColor(DataDrivenPropertyValue<Color> value, const } void FillLayer::setFillOutlineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillOutlineColor>(value, klass); + impl->cascading.template get<FillOutlineColor>().setTransition(value, klass); } TransitionOptions FillLayer::getFillOutlineColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillOutlineColor>(klass); + return impl->cascading.template get<FillOutlineColor>().getTransition(klass); } PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() { @@ -174,22 +174,22 @@ PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() { } PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate(const optional<std::string>& klass) const { - return impl->paint.get<FillTranslate>(klass); + return impl->cascading.template get<FillTranslate>().get(klass); } void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getFillTranslate(klass)) return; - impl->paint.set<FillTranslate>(value, klass); + impl->cascading.template get<FillTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillTranslate>(value, klass); + impl->cascading.template get<FillTranslate>().setTransition(value, klass); } TransitionOptions FillLayer::getFillTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillTranslate>(klass); + return impl->cascading.template get<FillTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() { @@ -197,22 +197,22 @@ PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() { } PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<FillTranslateAnchor>(klass); + return impl->cascading.template get<FillTranslateAnchor>().get(klass); } void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getFillTranslateAnchor(klass)) return; - impl->paint.set<FillTranslateAnchor>(value, klass); + impl->cascading.template get<FillTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillTranslateAnchor>(value, klass); + impl->cascading.template get<FillTranslateAnchor>().setTransition(value, klass); } TransitionOptions FillLayer::getFillTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillTranslateAnchor>(klass); + return impl->cascading.template get<FillTranslateAnchor>().getTransition(klass); } PropertyValue<std::string> FillLayer::getDefaultFillPattern() { @@ -220,22 +220,22 @@ PropertyValue<std::string> FillLayer::getDefaultFillPattern() { } PropertyValue<std::string> FillLayer::getFillPattern(const optional<std::string>& klass) const { - return impl->paint.get<FillPattern>(klass); + return impl->cascading.template get<FillPattern>().get(klass); } void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) { if (value == getFillPattern(klass)) return; - impl->paint.set<FillPattern>(value, klass); + impl->cascading.template get<FillPattern>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<FillPattern>(value, klass); + impl->cascading.template get<FillPattern>().setTransition(value, klass); } TransitionOptions FillLayer::getFillPatternTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<FillPattern>(klass); + return impl->cascading.template get<FillPattern>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp index 19675ca9fb..6ec55a58e3 100644 --- a/src/mbgl/style/layers/fill_layer_impl.cpp +++ b/src/mbgl/style/layers/fill_layer_impl.cpp @@ -1,55 +1,11 @@ #include <mbgl/style/layers/fill_layer_impl.hpp> -#include <mbgl/renderer/fill_bucket.hpp> -#include <mbgl/geometry/feature_index.hpp> -#include <mbgl/util/math.hpp> -#include <mbgl/util/intersection_tests.hpp> +#include <mbgl/renderer/render_fill_layer.hpp> namespace mbgl { namespace style { -void FillLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool FillLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - paint.evaluate(parameters); - - if (paint.unevaluated.get<FillOutlineColor>().isUndefined()) { - paint.evaluated.get<FillOutlineColor>() = paint.evaluated.get<FillColor>(); - } - - passes = RenderPass::None; - - if (paint.evaluated.get<FillAntialias>()) { - passes |= RenderPass::Translucent; - } - - if (!paint.unevaluated.get<FillPattern>().isUndefined() - || paint.evaluated.get<FillColor>().constantOr(Color()).a < 1.0f - || paint.evaluated.get<FillOpacity>().constantOr(0) < 1.0f) { - passes |= RenderPass::Translucent; - } else { - passes |= RenderPass::Opaque; - } - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> FillLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector<const Layer*>& layers) const { - return std::make_unique<FillBucket>(parameters, layers); -} - -bool FillLayer::Impl::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float, - const float bearing, - const float pixelsToTileUnits) const { - - auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( - queryGeometry, paint.evaluated.get<FillTranslate>(), paint.evaluated.get<FillTranslateAnchor>(), bearing, pixelsToTileUnits); - - return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries()); +std::unique_ptr<RenderLayer> FillLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderFillLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp index 712cb0a6e0..215558962e 100644 --- a/src/mbgl/style/layers/fill_layer_impl.hpp +++ b/src/mbgl/style/layers/fill_layer_impl.hpp @@ -13,19 +13,9 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const float, - const float) const override; - - FillPaintProperties paint; + FillPaintProperties::Cascading cascading; }; } // namespace style diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs index 76c83f474a..2f690c3158 100644 --- a/src/mbgl/style/layers/layer.cpp.ejs +++ b/src/mbgl/style/layers/layer.cpp.ejs @@ -14,13 +14,13 @@ namespace style { <% if (type === 'background') { -%> <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID) - : Layer(Type::<%- camelize(type) %>, std::make_unique<Impl>()) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; } <% } else { -%> <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::<%- camelize(type) %>, std::make_unique<Impl>()) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; @@ -28,7 +28,7 @@ namespace style { <% } -%> <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const Impl& other) - : Layer(Type::<%- camelize(type) %>, std::make_unique<Impl>(other)) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -41,7 +41,7 @@ std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::clone() const { std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<<%- camelize(type) %>Layer>(*this); result->impl->id = id_; - result->impl->paint = <%- camelize(type) %>PaintProperties(); + result->impl->cascading = <%- camelize(type) %>PaintProperties::Cascading(); return std::move(result); } @@ -109,13 +109,13 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV } <%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(const optional<std::string>& klass) const { - return impl->paint.get<<%- camelize(property.name) %>>(klass); + return impl->cascading.template get<<%- camelize(property.name) %>>().get(klass); } void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value, const optional<std::string>& klass) { if (value == get<%- camelize(property.name) %>(klass)) return; - impl->paint.set<<%- camelize(property.name) %>>(value, klass); + impl->cascading.template get<<%- camelize(property.name) %>>().set(value, klass); <% if (isDataDriven(property)) { -%> if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); @@ -128,11 +128,11 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV } void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<<%- camelize(property.name) %>>(value, klass); + impl->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass); } TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(const optional<std::string>& klass) const { - return impl->paint.getTransition<<%- camelize(property.name) %>>(klass); + return impl->cascading.template get<<%- camelize(property.name) %>>().getTransition(klass); } <% } -%> diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp index cfb68f3262..7f1575aad5 100644 --- a/src/mbgl/style/layers/line_layer.cpp +++ b/src/mbgl/style/layers/line_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { LineLayer::LineLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::Line, std::make_unique<Impl>()) + : Layer(LayerType::Line, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } LineLayer::LineLayer(const Impl& other) - : Layer(Type::Line, std::make_unique<Impl>(other)) + : Layer(LayerType::Line, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> LineLayer::Impl::clone() const { std::unique_ptr<Layer> LineLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<LineLayer>(*this); result->impl->id = id_; - result->impl->paint = LinePaintProperties(); + result->impl->cascading = LinePaintProperties::Cascading(); return std::move(result); } @@ -127,13 +127,13 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOpacity() { } DataDrivenPropertyValue<float> LineLayer::getLineOpacity(const optional<std::string>& klass) const { - return impl->paint.get<LineOpacity>(klass); + return impl->cascading.template get<LineOpacity>().get(klass); } void LineLayer::setLineOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getLineOpacity(klass)) return; - impl->paint.set<LineOpacity>(value, klass); + impl->cascading.template get<LineOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -142,11 +142,11 @@ void LineLayer::setLineOpacity(DataDrivenPropertyValue<float> value, const optio } void LineLayer::setLineOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineOpacity>(value, klass); + impl->cascading.template get<LineOpacity>().setTransition(value, klass); } TransitionOptions LineLayer::getLineOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineOpacity>(klass); + return impl->cascading.template get<LineOpacity>().getTransition(klass); } DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() { @@ -154,13 +154,13 @@ DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() { } DataDrivenPropertyValue<Color> LineLayer::getLineColor(const optional<std::string>& klass) const { - return impl->paint.get<LineColor>(klass); + return impl->cascading.template get<LineColor>().get(klass); } void LineLayer::setLineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getLineColor(klass)) return; - impl->paint.set<LineColor>(value, klass); + impl->cascading.template get<LineColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -169,11 +169,11 @@ void LineLayer::setLineColor(DataDrivenPropertyValue<Color> value, const optiona } void LineLayer::setLineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineColor>(value, klass); + impl->cascading.template get<LineColor>().setTransition(value, klass); } TransitionOptions LineLayer::getLineColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineColor>(klass); + return impl->cascading.template get<LineColor>().getTransition(klass); } PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() { @@ -181,22 +181,22 @@ PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() { } PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate(const optional<std::string>& klass) const { - return impl->paint.get<LineTranslate>(klass); + return impl->cascading.template get<LineTranslate>().get(klass); } void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getLineTranslate(klass)) return; - impl->paint.set<LineTranslate>(value, klass); + impl->cascading.template get<LineTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineTranslate>(value, klass); + impl->cascading.template get<LineTranslate>().setTransition(value, klass); } TransitionOptions LineLayer::getLineTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineTranslate>(klass); + return impl->cascading.template get<LineTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() { @@ -204,22 +204,22 @@ PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() { } PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<LineTranslateAnchor>(klass); + return impl->cascading.template get<LineTranslateAnchor>().get(klass); } void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getLineTranslateAnchor(klass)) return; - impl->paint.set<LineTranslateAnchor>(value, klass); + impl->cascading.template get<LineTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineTranslateAnchor>(value, klass); + impl->cascading.template get<LineTranslateAnchor>().setTransition(value, klass); } TransitionOptions LineLayer::getLineTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineTranslateAnchor>(klass); + return impl->cascading.template get<LineTranslateAnchor>().getTransition(klass); } PropertyValue<float> LineLayer::getDefaultLineWidth() { @@ -227,22 +227,22 @@ PropertyValue<float> LineLayer::getDefaultLineWidth() { } PropertyValue<float> LineLayer::getLineWidth(const optional<std::string>& klass) const { - return impl->paint.get<LineWidth>(klass); + return impl->cascading.template get<LineWidth>().get(klass); } void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getLineWidth(klass)) return; - impl->paint.set<LineWidth>(value, klass); + impl->cascading.template get<LineWidth>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineWidth>(value, klass); + impl->cascading.template get<LineWidth>().setTransition(value, klass); } TransitionOptions LineLayer::getLineWidthTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineWidth>(klass); + return impl->cascading.template get<LineWidth>().getTransition(klass); } DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() { @@ -250,13 +250,13 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() { } DataDrivenPropertyValue<float> LineLayer::getLineGapWidth(const optional<std::string>& klass) const { - return impl->paint.get<LineGapWidth>(klass); + return impl->cascading.template get<LineGapWidth>().get(klass); } void LineLayer::setLineGapWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getLineGapWidth(klass)) return; - impl->paint.set<LineGapWidth>(value, klass); + impl->cascading.template get<LineGapWidth>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -265,11 +265,11 @@ void LineLayer::setLineGapWidth(DataDrivenPropertyValue<float> value, const opti } void LineLayer::setLineGapWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineGapWidth>(value, klass); + impl->cascading.template get<LineGapWidth>().setTransition(value, klass); } TransitionOptions LineLayer::getLineGapWidthTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineGapWidth>(klass); + return impl->cascading.template get<LineGapWidth>().getTransition(klass); } DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() { @@ -277,13 +277,13 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() { } DataDrivenPropertyValue<float> LineLayer::getLineOffset(const optional<std::string>& klass) const { - return impl->paint.get<LineOffset>(klass); + return impl->cascading.template get<LineOffset>().get(klass); } void LineLayer::setLineOffset(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getLineOffset(klass)) return; - impl->paint.set<LineOffset>(value, klass); + impl->cascading.template get<LineOffset>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -292,11 +292,11 @@ void LineLayer::setLineOffset(DataDrivenPropertyValue<float> value, const option } void LineLayer::setLineOffsetTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineOffset>(value, klass); + impl->cascading.template get<LineOffset>().setTransition(value, klass); } TransitionOptions LineLayer::getLineOffsetTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineOffset>(klass); + return impl->cascading.template get<LineOffset>().getTransition(klass); } DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() { @@ -304,13 +304,13 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() { } DataDrivenPropertyValue<float> LineLayer::getLineBlur(const optional<std::string>& klass) const { - return impl->paint.get<LineBlur>(klass); + return impl->cascading.template get<LineBlur>().get(klass); } void LineLayer::setLineBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getLineBlur(klass)) return; - impl->paint.set<LineBlur>(value, klass); + impl->cascading.template get<LineBlur>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -319,11 +319,11 @@ void LineLayer::setLineBlur(DataDrivenPropertyValue<float> value, const optional } void LineLayer::setLineBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineBlur>(value, klass); + impl->cascading.template get<LineBlur>().setTransition(value, klass); } TransitionOptions LineLayer::getLineBlurTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineBlur>(klass); + return impl->cascading.template get<LineBlur>().getTransition(klass); } PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() { @@ -331,22 +331,22 @@ PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() { } PropertyValue<std::vector<float>> LineLayer::getLineDasharray(const optional<std::string>& klass) const { - return impl->paint.get<LineDasharray>(klass); + return impl->cascading.template get<LineDasharray>().get(klass); } void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) { if (value == getLineDasharray(klass)) return; - impl->paint.set<LineDasharray>(value, klass); + impl->cascading.template get<LineDasharray>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineDasharrayTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LineDasharray>(value, klass); + impl->cascading.template get<LineDasharray>().setTransition(value, klass); } TransitionOptions LineLayer::getLineDasharrayTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LineDasharray>(klass); + return impl->cascading.template get<LineDasharray>().getTransition(klass); } PropertyValue<std::string> LineLayer::getDefaultLinePattern() { @@ -354,22 +354,22 @@ PropertyValue<std::string> LineLayer::getDefaultLinePattern() { } PropertyValue<std::string> LineLayer::getLinePattern(const optional<std::string>& klass) const { - return impl->paint.get<LinePattern>(klass); + return impl->cascading.template get<LinePattern>().get(klass); } void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) { if (value == getLinePattern(klass)) return; - impl->paint.set<LinePattern>(value, klass); + impl->cascading.template get<LinePattern>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLinePatternTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<LinePattern>(value, klass); + impl->cascading.template get<LinePattern>().setTransition(value, klass); } TransitionOptions LineLayer::getLinePatternTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<LinePattern>(klass); + return impl->cascading.template get<LinePattern>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp index d283292914..973a77abf4 100644 --- a/src/mbgl/style/layers/line_layer_impl.cpp +++ b/src/mbgl/style/layers/line_layer_impl.cpp @@ -1,102 +1,11 @@ #include <mbgl/style/layers/line_layer_impl.hpp> -#include <mbgl/style/property_evaluation_parameters.hpp> -#include <mbgl/renderer/line_bucket.hpp> -#include <mbgl/geometry/feature_index.hpp> -#include <mbgl/util/math.hpp> -#include <mbgl/util/intersection_tests.hpp> +#include <mbgl/renderer/render_line_layer.hpp> namespace mbgl { namespace style { -void LineLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool LineLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - // for scaling dasharrays - PropertyEvaluationParameters dashArrayParams = parameters; - dashArrayParams.z = std::floor(dashArrayParams.z); - dashLineWidth = paint.evaluate<LineWidth>(dashArrayParams); - - paint.evaluate(parameters); - - passes = (paint.evaluated.get<LineOpacity>().constantOr(1.0) > 0 - && paint.evaluated.get<LineColor>().constantOr(Color::black()).a > 0 - && paint.evaluated.get<LineWidth>() > 0) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> LineLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector<const Layer*>& layers) const { - return std::make_unique<LineBucket>(parameters, layers, layout); -} - -float LineLayer::Impl::getLineWidth(const GeometryTileFeature& feature, const float zoom) const { - float lineWidth = paint.evaluated.get<LineWidth>(); - float gapWidth = paint.evaluated.get<LineGapWidth>() - .evaluate(feature, zoom, LineGapWidth::defaultValue()); - if (gapWidth) { - return gapWidth + 2 * lineWidth; - } else { - return lineWidth; - } -} - -optional<GeometryCollection> offsetLine(const GeometryCollection& rings, const double offset) { - if (offset == 0) return {}; - - GeometryCollection newRings; - Point<double> zero(0, 0); - for (const auto& ring : rings) { - newRings.emplace_back(); - auto& newRing = newRings.back(); - - for (auto i = ring.begin(); i != ring.end(); i++) { - auto& p = *i; - - Point<double> aToB = i == ring.begin() ? - zero : - util::perp(util::unit(convertPoint<double>(p - *(i - 1)))); - Point<double> bToC = i + 1 == ring.end() ? - zero : - util::perp(util::unit(convertPoint<double>(*(i + 1) - p))); - Point<double> extrude = util::unit(aToB + bToC); - - const double cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y; - extrude *= (1.0 / cosHalfAngle); - - newRing.push_back(convertPoint<int16_t>(extrude * offset) + p); - } - } - - return newRings; -} - -bool LineLayer::Impl::queryIntersectsFeature( - const GeometryCoordinates& queryGeometry, - const GeometryTileFeature& feature, - const float zoom, - const float bearing, - const float pixelsToTileUnits) const { - - // Translate query geometry - auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( - queryGeometry, paint.evaluated.get<LineTranslate>(), paint.evaluated.get<LineTranslateAnchor>(), bearing, pixelsToTileUnits); - - - // Evaluate function - auto offset = paint.evaluated.get<LineOffset>().evaluate(feature, zoom, LineOffset::defaultValue()) * pixelsToTileUnits; - - // Apply offset to geometry - auto offsetGeometry = offsetLine(feature.getGeometries(), offset); - - // Test intersection - const float halfWidth = getLineWidth(feature, zoom) / 2.0 * pixelsToTileUnits; - return util::polygonIntersectsBufferedMultiLine( - translatedQueryGeometry.value_or(queryGeometry), - offsetGeometry.value_or(feature.getGeometries()), - halfWidth); +std::unique_ptr<RenderLayer> LineLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderLineLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp index b25ece3100..02c9c85f00 100644 --- a/src/mbgl/style/layers/line_layer_impl.hpp +++ b/src/mbgl/style/layers/line_layer_impl.hpp @@ -13,26 +13,10 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; - - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const float, - const float) const override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; LineLayoutProperties layout; - LinePaintProperties paint; - - // Special case - float dashLineWidth = 1; - -private: - float getLineWidth(const GeometryTileFeature&, const float) const; + LinePaintProperties::Cascading cascading; }; } // namespace style diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp index dfdd13e63c..b525f9eaa4 100644 --- a/src/mbgl/style/layers/raster_layer.cpp +++ b/src/mbgl/style/layers/raster_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { RasterLayer::RasterLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::Raster, std::make_unique<Impl>()) + : Layer(LayerType::Raster, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } RasterLayer::RasterLayer(const Impl& other) - : Layer(Type::Raster, std::make_unique<Impl>(other)) + : Layer(LayerType::Raster, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> RasterLayer::Impl::clone() const { std::unique_ptr<Layer> RasterLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<RasterLayer>(*this); result->impl->id = id_; - result->impl->paint = RasterPaintProperties(); + result->impl->cascading = RasterPaintProperties::Cascading(); return std::move(result); } @@ -52,22 +52,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterOpacity() { } PropertyValue<float> RasterLayer::getRasterOpacity(const optional<std::string>& klass) const { - return impl->paint.get<RasterOpacity>(klass); + return impl->cascading.template get<RasterOpacity>().get(klass); } void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterOpacity(klass)) return; - impl->paint.set<RasterOpacity>(value, klass); + impl->cascading.template get<RasterOpacity>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterOpacity>(value, klass); + impl->cascading.template get<RasterOpacity>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterOpacity>(klass); + return impl->cascading.template get<RasterOpacity>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() { @@ -75,22 +75,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() { } PropertyValue<float> RasterLayer::getRasterHueRotate(const optional<std::string>& klass) const { - return impl->paint.get<RasterHueRotate>(klass); + return impl->cascading.template get<RasterHueRotate>().get(klass); } void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterHueRotate(klass)) return; - impl->paint.set<RasterHueRotate>(value, klass); + impl->cascading.template get<RasterHueRotate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterHueRotate>(value, klass); + impl->cascading.template get<RasterHueRotate>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterHueRotateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterHueRotate>(klass); + return impl->cascading.template get<RasterHueRotate>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() { @@ -98,22 +98,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() { } PropertyValue<float> RasterLayer::getRasterBrightnessMin(const optional<std::string>& klass) const { - return impl->paint.get<RasterBrightnessMin>(klass); + return impl->cascading.template get<RasterBrightnessMin>().get(klass); } void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterBrightnessMin(klass)) return; - impl->paint.set<RasterBrightnessMin>(value, klass); + impl->cascading.template get<RasterBrightnessMin>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterBrightnessMin>(value, klass); + impl->cascading.template get<RasterBrightnessMin>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterBrightnessMinTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterBrightnessMin>(klass); + return impl->cascading.template get<RasterBrightnessMin>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() { @@ -121,22 +121,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() { } PropertyValue<float> RasterLayer::getRasterBrightnessMax(const optional<std::string>& klass) const { - return impl->paint.get<RasterBrightnessMax>(klass); + return impl->cascading.template get<RasterBrightnessMax>().get(klass); } void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterBrightnessMax(klass)) return; - impl->paint.set<RasterBrightnessMax>(value, klass); + impl->cascading.template get<RasterBrightnessMax>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterBrightnessMax>(value, klass); + impl->cascading.template get<RasterBrightnessMax>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterBrightnessMaxTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterBrightnessMax>(klass); + return impl->cascading.template get<RasterBrightnessMax>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterSaturation() { @@ -144,22 +144,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterSaturation() { } PropertyValue<float> RasterLayer::getRasterSaturation(const optional<std::string>& klass) const { - return impl->paint.get<RasterSaturation>(klass); + return impl->cascading.template get<RasterSaturation>().get(klass); } void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterSaturation(klass)) return; - impl->paint.set<RasterSaturation>(value, klass); + impl->cascading.template get<RasterSaturation>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterSaturation>(value, klass); + impl->cascading.template get<RasterSaturation>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterSaturationTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterSaturation>(klass); + return impl->cascading.template get<RasterSaturation>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterContrast() { @@ -167,22 +167,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterContrast() { } PropertyValue<float> RasterLayer::getRasterContrast(const optional<std::string>& klass) const { - return impl->paint.get<RasterContrast>(klass); + return impl->cascading.template get<RasterContrast>().get(klass); } void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterContrast(klass)) return; - impl->paint.set<RasterContrast>(value, klass); + impl->cascading.template get<RasterContrast>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterContrast>(value, klass); + impl->cascading.template get<RasterContrast>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterContrastTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterContrast>(klass); + return impl->cascading.template get<RasterContrast>().getTransition(klass); } PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() { @@ -190,22 +190,22 @@ PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() { } PropertyValue<float> RasterLayer::getRasterFadeDuration(const optional<std::string>& klass) const { - return impl->paint.get<RasterFadeDuration>(klass); + return impl->cascading.template get<RasterFadeDuration>().get(klass); } void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) { if (value == getRasterFadeDuration(klass)) return; - impl->paint.set<RasterFadeDuration>(value, klass); + impl->cascading.template get<RasterFadeDuration>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<RasterFadeDuration>(value, klass); + impl->cascading.template get<RasterFadeDuration>().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterFadeDurationTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<RasterFadeDuration>(klass); + return impl->cascading.template get<RasterFadeDuration>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp index a667ccb5a8..fa9f80dac6 100644 --- a/src/mbgl/style/layers/raster_layer_impl.cpp +++ b/src/mbgl/style/layers/raster_layer_impl.cpp @@ -1,24 +1,11 @@ #include <mbgl/style/layers/raster_layer_impl.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/render_raster_layer.hpp> namespace mbgl { namespace style { -void RasterLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool RasterLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - paint.evaluate(parameters); - - passes = paint.evaluated.get<RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> RasterLayer::Impl::createBucket(const BucketParameters&, const std::vector<const Layer*>&) const { - assert(false); - return nullptr; +std::unique_ptr<RenderLayer> RasterLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderRasterLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp index 42985ce0f1..edf5f9111b 100644 --- a/src/mbgl/style/layers/raster_layer_impl.hpp +++ b/src/mbgl/style/layers/raster_layer_impl.hpp @@ -13,12 +13,9 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr<RenderLayer> createRenderLayer() const override; - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - - RasterPaintProperties paint; + RasterPaintProperties::Cascading cascading; }; } // namespace style diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp index e79a3f967f..273a9fd24e 100644 --- a/src/mbgl/style/layers/symbol_layer.cpp +++ b/src/mbgl/style/layers/symbol_layer.cpp @@ -8,14 +8,14 @@ namespace mbgl { namespace style { SymbolLayer::SymbolLayer(const std::string& layerID, const std::string& sourceID) - : Layer(Type::Symbol, std::make_unique<Impl>()) + : Layer(LayerType::Symbol, std::make_unique<Impl>()) , impl(static_cast<Impl*>(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } SymbolLayer::SymbolLayer(const Impl& other) - : Layer(Type::Symbol, std::make_unique<Impl>(other)) + : Layer(LayerType::Symbol, std::make_unique<Impl>(other)) , impl(static_cast<Impl*>(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr<Layer> SymbolLayer::Impl::clone() const { std::unique_ptr<Layer> SymbolLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique<SymbolLayer>(*this); result->impl->id = id_; - result->impl->paint = SymbolPaintProperties(); + result->impl->cascading = SymbolPaintProperties::Cascading(); return std::move(result); } @@ -547,13 +547,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconOpacity() { } DataDrivenPropertyValue<float> SymbolLayer::getIconOpacity(const optional<std::string>& klass) const { - return impl->paint.get<IconOpacity>(klass); + return impl->cascading.template get<IconOpacity>().get(klass); } void SymbolLayer::setIconOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getIconOpacity(klass)) return; - impl->paint.set<IconOpacity>(value, klass); + impl->cascading.template get<IconOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -562,11 +562,11 @@ void SymbolLayer::setIconOpacity(DataDrivenPropertyValue<float> value, const opt } void SymbolLayer::setIconOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconOpacity>(value, klass); + impl->cascading.template get<IconOpacity>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconOpacity>(klass); + return impl->cascading.template get<IconOpacity>().getTransition(klass); } DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() { @@ -574,13 +574,13 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() { } DataDrivenPropertyValue<Color> SymbolLayer::getIconColor(const optional<std::string>& klass) const { - return impl->paint.get<IconColor>(klass); + return impl->cascading.template get<IconColor>().get(klass); } void SymbolLayer::setIconColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getIconColor(klass)) return; - impl->paint.set<IconColor>(value, klass); + impl->cascading.template get<IconColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -589,11 +589,11 @@ void SymbolLayer::setIconColor(DataDrivenPropertyValue<Color> value, const optio } void SymbolLayer::setIconColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconColor>(value, klass); + impl->cascading.template get<IconColor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconColor>(klass); + return impl->cascading.template get<IconColor>().getTransition(klass); } DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() { @@ -601,13 +601,13 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() { } DataDrivenPropertyValue<Color> SymbolLayer::getIconHaloColor(const optional<std::string>& klass) const { - return impl->paint.get<IconHaloColor>(klass); + return impl->cascading.template get<IconHaloColor>().get(klass); } void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getIconHaloColor(klass)) return; - impl->paint.set<IconHaloColor>(value, klass); + impl->cascading.template get<IconHaloColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -616,11 +616,11 @@ void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue<Color> value, const o } void SymbolLayer::setIconHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconHaloColor>(value, klass); + impl->cascading.template get<IconHaloColor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconHaloColor>(klass); + return impl->cascading.template get<IconHaloColor>().getTransition(klass); } DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() { @@ -628,13 +628,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() { } DataDrivenPropertyValue<float> SymbolLayer::getIconHaloWidth(const optional<std::string>& klass) const { - return impl->paint.get<IconHaloWidth>(klass); + return impl->cascading.template get<IconHaloWidth>().get(klass); } void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getIconHaloWidth(klass)) return; - impl->paint.set<IconHaloWidth>(value, klass); + impl->cascading.template get<IconHaloWidth>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -643,11 +643,11 @@ void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue<float> value, const o } void SymbolLayer::setIconHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconHaloWidth>(value, klass); + impl->cascading.template get<IconHaloWidth>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloWidthTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconHaloWidth>(klass); + return impl->cascading.template get<IconHaloWidth>().getTransition(klass); } DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() { @@ -655,13 +655,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() { } DataDrivenPropertyValue<float> SymbolLayer::getIconHaloBlur(const optional<std::string>& klass) const { - return impl->paint.get<IconHaloBlur>(klass); + return impl->cascading.template get<IconHaloBlur>().get(klass); } void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getIconHaloBlur(klass)) return; - impl->paint.set<IconHaloBlur>(value, klass); + impl->cascading.template get<IconHaloBlur>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -670,11 +670,11 @@ void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue<float> value, const op } void SymbolLayer::setIconHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconHaloBlur>(value, klass); + impl->cascading.template get<IconHaloBlur>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloBlurTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconHaloBlur>(klass); + return impl->cascading.template get<IconHaloBlur>().getTransition(klass); } PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() { @@ -682,22 +682,22 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() { } PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate(const optional<std::string>& klass) const { - return impl->paint.get<IconTranslate>(klass); + return impl->cascading.template get<IconTranslate>().get(klass); } void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getIconTranslate(klass)) return; - impl->paint.set<IconTranslate>(value, klass); + impl->cascading.template get<IconTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setIconTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconTranslate>(value, klass); + impl->cascading.template get<IconTranslate>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconTranslate>(klass); + return impl->cascading.template get<IconTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor() { @@ -705,22 +705,22 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor() } PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<IconTranslateAnchor>(klass); + return impl->cascading.template get<IconTranslateAnchor>().get(klass); } void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getIconTranslateAnchor(klass)) return; - impl->paint.set<IconTranslateAnchor>(value, klass); + impl->cascading.template get<IconTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setIconTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<IconTranslateAnchor>(value, klass); + impl->cascading.template get<IconTranslateAnchor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<IconTranslateAnchor>(klass); + return impl->cascading.template get<IconTranslateAnchor>().getTransition(klass); } DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() { @@ -728,13 +728,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() { } DataDrivenPropertyValue<float> SymbolLayer::getTextOpacity(const optional<std::string>& klass) const { - return impl->paint.get<TextOpacity>(klass); + return impl->cascading.template get<TextOpacity>().get(klass); } void SymbolLayer::setTextOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getTextOpacity(klass)) return; - impl->paint.set<TextOpacity>(value, klass); + impl->cascading.template get<TextOpacity>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -743,11 +743,11 @@ void SymbolLayer::setTextOpacity(DataDrivenPropertyValue<float> value, const opt } void SymbolLayer::setTextOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextOpacity>(value, klass); + impl->cascading.template get<TextOpacity>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextOpacityTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextOpacity>(klass); + return impl->cascading.template get<TextOpacity>().getTransition(klass); } DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() { @@ -755,13 +755,13 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() { } DataDrivenPropertyValue<Color> SymbolLayer::getTextColor(const optional<std::string>& klass) const { - return impl->paint.get<TextColor>(klass); + return impl->cascading.template get<TextColor>().get(klass); } void SymbolLayer::setTextColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getTextColor(klass)) return; - impl->paint.set<TextColor>(value, klass); + impl->cascading.template get<TextColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -770,11 +770,11 @@ void SymbolLayer::setTextColor(DataDrivenPropertyValue<Color> value, const optio } void SymbolLayer::setTextColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextColor>(value, klass); + impl->cascading.template get<TextColor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextColor>(klass); + return impl->cascading.template get<TextColor>().getTransition(klass); } DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() { @@ -782,13 +782,13 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() { } DataDrivenPropertyValue<Color> SymbolLayer::getTextHaloColor(const optional<std::string>& klass) const { - return impl->paint.get<TextHaloColor>(klass); + return impl->cascading.template get<TextHaloColor>().get(klass); } void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) { if (value == getTextHaloColor(klass)) return; - impl->paint.set<TextHaloColor>(value, klass); + impl->cascading.template get<TextHaloColor>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -797,11 +797,11 @@ void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue<Color> value, const o } void SymbolLayer::setTextHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextHaloColor>(value, klass); + impl->cascading.template get<TextHaloColor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloColorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextHaloColor>(klass); + return impl->cascading.template get<TextHaloColor>().getTransition(klass); } DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() { @@ -809,13 +809,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() { } DataDrivenPropertyValue<float> SymbolLayer::getTextHaloWidth(const optional<std::string>& klass) const { - return impl->paint.get<TextHaloWidth>(klass); + return impl->cascading.template get<TextHaloWidth>().get(klass); } void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getTextHaloWidth(klass)) return; - impl->paint.set<TextHaloWidth>(value, klass); + impl->cascading.template get<TextHaloWidth>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -824,11 +824,11 @@ void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue<float> value, const o } void SymbolLayer::setTextHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextHaloWidth>(value, klass); + impl->cascading.template get<TextHaloWidth>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloWidthTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextHaloWidth>(klass); + return impl->cascading.template get<TextHaloWidth>().getTransition(klass); } DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() { @@ -836,13 +836,13 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() { } DataDrivenPropertyValue<float> SymbolLayer::getTextHaloBlur(const optional<std::string>& klass) const { - return impl->paint.get<TextHaloBlur>(klass); + return impl->cascading.template get<TextHaloBlur>().get(klass); } void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) { if (value == getTextHaloBlur(klass)) return; - impl->paint.set<TextHaloBlur>(value, klass); + impl->cascading.template get<TextHaloBlur>().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -851,11 +851,11 @@ void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue<float> value, const op } void SymbolLayer::setTextHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextHaloBlur>(value, klass); + impl->cascading.template get<TextHaloBlur>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloBlurTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextHaloBlur>(klass); + return impl->cascading.template get<TextHaloBlur>().getTransition(klass); } PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() { @@ -863,22 +863,22 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() { } PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate(const optional<std::string>& klass) const { - return impl->paint.get<TextTranslate>(klass); + return impl->cascading.template get<TextTranslate>().get(klass); } void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) { if (value == getTextTranslate(klass)) return; - impl->paint.set<TextTranslate>(value, klass); + impl->cascading.template get<TextTranslate>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setTextTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextTranslate>(value, klass); + impl->cascading.template get<TextTranslate>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextTranslateTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextTranslate>(klass); + return impl->cascading.template get<TextTranslate>().getTransition(klass); } PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor() { @@ -886,22 +886,22 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor() } PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor(const optional<std::string>& klass) const { - return impl->paint.get<TextTranslateAnchor>(klass); + return impl->cascading.template get<TextTranslateAnchor>().get(klass); } void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) { if (value == getTextTranslateAnchor(klass)) return; - impl->paint.set<TextTranslateAnchor>(value, klass); + impl->cascading.template get<TextTranslateAnchor>().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setTextTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) { - impl->paint.setTransition<TextTranslateAnchor>(value, klass); + impl->cascading.template get<TextTranslateAnchor>().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextTranslateAnchorTransition(const optional<std::string>& klass) const { - return impl->paint.getTransition<TextTranslateAnchor>(klass); + return impl->cascading.template get<TextTranslateAnchor>().getTransition(klass); } } // namespace style diff --git a/src/mbgl/style/layers/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp index 109d1c43e7..c99dd8ad70 100644 --- a/src/mbgl/style/layers/symbol_layer_impl.cpp +++ b/src/mbgl/style/layers/symbol_layer_impl.cpp @@ -1,101 +1,11 @@ #include <mbgl/style/layers/symbol_layer_impl.hpp> -#include <mbgl/style/property_evaluation_parameters.hpp> -#include <mbgl/layout/symbol_layout.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/render_symbol_layer.hpp> namespace mbgl { namespace style { -void SymbolLayer::Impl::cascade(const CascadeParameters& parameters) { - paint.cascade(parameters); -} - -bool SymbolLayer::Impl::evaluate(const PropertyEvaluationParameters& parameters) { - paint.evaluate(parameters); - - auto hasIconOpacity = paint.evaluated.get<IconColor>().constantOr(Color::black()).a > 0 || - paint.evaluated.get<IconHaloColor>().constantOr(Color::black()).a > 0; - auto hasTextOpacity = paint.evaluated.get<TextColor>().constantOr(Color::black()).a > 0 || - paint.evaluated.get<TextHaloColor>().constantOr(Color::black()).a > 0; - - passes = ((paint.evaluated.get<IconOpacity>().constantOr(1) > 0 && hasIconOpacity && iconSize > 0) - || (paint.evaluated.get<TextOpacity>().constantOr(1) > 0 && hasTextOpacity && textSize > 0)) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(const BucketParameters&, const std::vector<const Layer*>&) const { - assert(false); // Should be calling createLayout() instead. - return nullptr; -} - -std::unique_ptr<SymbolLayout> SymbolLayer::Impl::createLayout(const BucketParameters& parameters, - const std::vector<const Layer*>& group, - const GeometryTileLayer& layer, - GlyphDependencies& glyphDependencies, - IconDependencyMap& iconDependencyMap) const { - return std::make_unique<SymbolLayout>(parameters, - group, - layer, - iconDependencyMap[spriteAtlas], - (uintptr_t)spriteAtlas, - glyphDependencies); -} - -IconPaintProperties::Evaluated SymbolLayer::Impl::iconPaintProperties() const { - return IconPaintProperties::Evaluated { - paint.evaluated.get<IconOpacity>(), - paint.evaluated.get<IconColor>(), - paint.evaluated.get<IconHaloColor>(), - paint.evaluated.get<IconHaloWidth>(), - paint.evaluated.get<IconHaloBlur>(), - paint.evaluated.get<IconTranslate>(), - paint.evaluated.get<IconTranslateAnchor>() - }; -} - -TextPaintProperties::Evaluated SymbolLayer::Impl::textPaintProperties() const { - return TextPaintProperties::Evaluated { - paint.evaluated.get<TextOpacity>(), - paint.evaluated.get<TextColor>(), - paint.evaluated.get<TextHaloColor>(), - paint.evaluated.get<TextHaloWidth>(), - paint.evaluated.get<TextHaloBlur>(), - paint.evaluated.get<TextTranslate>(), - paint.evaluated.get<TextTranslateAnchor>() - }; -} - - -SymbolPropertyValues SymbolLayer::Impl::iconPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated& layout_) const { - return SymbolPropertyValues { - layout_.get<IconRotationAlignment>(), // icon-pitch-alignment is not yet implemented; inherit the rotation alignment - layout_.get<IconRotationAlignment>(), - layout_.get<IconSize>(), - paint.evaluated.get<IconTranslate>(), - paint.evaluated.get<IconTranslateAnchor>(), - iconSize, - 1.0f, - paint.evaluated.get<IconHaloColor>().constantOr(Color::black()).a > 0 && - paint.evaluated.get<IconHaloWidth>().constantOr(1), - paint.evaluated.get<IconColor>().constantOr(Color::black()).a > 0 - }; -} - -SymbolPropertyValues SymbolLayer::Impl::textPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated& layout_) const { - return SymbolPropertyValues { - layout_.get<TextPitchAlignment>(), - layout_.get<TextRotationAlignment>(), - layout_.get<TextSize>(), - paint.evaluated.get<TextTranslate>(), - paint.evaluated.get<TextTranslateAnchor>(), - textSize, - 24.0f, - paint.evaluated.get<TextHaloColor>().constantOr(Color::black()).a > 0 && - paint.evaluated.get<TextHaloWidth>().constantOr(1), - paint.evaluated.get<TextColor>().constantOr(Color::black()).a > 0 - }; +std::unique_ptr<RenderLayer> SymbolLayer::Impl::createRenderLayer() const { + return std::make_unique<RenderSymbolLayer>(*this); } } // namespace style diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp index 3d81ff1f69..28079fa731 100644 --- a/src/mbgl/style/layers/symbol_layer_impl.hpp +++ b/src/mbgl/style/layers/symbol_layer_impl.hpp @@ -1,7 +1,5 @@ #pragma once -#include <mbgl/text/glyph.hpp> -#include <mbgl/util/variant.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/style/layer_impl.hpp> #include <mbgl/style/layers/symbol_layer.hpp> @@ -9,53 +7,7 @@ namespace mbgl { -class SymbolLayout; - namespace style { - - -// {icon,text}-specific paint-property packs for use in the symbol Programs. -// Since each program deals either with icons or text, using a smaller property set -// lets us avoid unnecessarily binding attributes for properties the program wouldn't use. -class IconPaintProperties : public PaintProperties< - IconOpacity, - IconColor, - IconHaloColor, - IconHaloWidth, - IconHaloBlur, - IconTranslate, - IconTranslateAnchor -> {}; - -class TextPaintProperties : public PaintProperties< - TextOpacity, - TextColor, - TextHaloColor, - TextHaloWidth, - TextHaloBlur, - TextTranslate, - TextTranslateAnchor -> {}; - -// Repackaging evaluated values from SymbolLayoutProperties + SymbolPaintProperties -// for genericity over icons vs. text. -class SymbolPropertyValues { -public: - // Layout - AlignmentType pitchAlignment; - AlignmentType rotationAlignment; - PossiblyEvaluatedPropertyValue<float> layoutSize; - - // Paint - std::array<float, 2> translate; - TranslateAnchorType translateAnchor; - float paintSize; - - float sdfScale; // Constant (1.0 or 24.0) - - bool hasHalo; - bool hasFill; -}; class SymbolLayer::Impl : public Layer::Impl { public: @@ -63,24 +15,10 @@ public: std::unique_ptr<Layer> cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; - - std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const override; - std::unique_ptr<SymbolLayout> createLayout(const BucketParameters&, const std::vector<const Layer*>&, - const GeometryTileLayer&, GlyphDependencies&, IconDependencyMap&) const; - - IconPaintProperties::Evaluated iconPaintProperties() const; - TextPaintProperties::Evaluated textPaintProperties() const; - - SymbolPropertyValues iconPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated&) const; - SymbolPropertyValues textPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated&) const; + std::unique_ptr<RenderLayer> createRenderLayer() const override; SymbolLayoutProperties layout; - SymbolPaintProperties paint; - - float iconSize = 1.0f; - float textSize = 16.0f; + SymbolPaintProperties::Cascading cascading; SpriteAtlas* spriteAtlas = nullptr; }; |