diff options
author | Ivo van Dongen <info@ivovandongen.nl> | 2017-04-21 09:19:47 -0700 |
---|---|---|
committer | Ivo van Dongen <ivovandongen@users.noreply.github.com> | 2017-04-25 17:23:54 -0700 |
commit | 3c175adf30546fe58713b8fed29ac35a85e150be (patch) | |
tree | 5666e9bcf311ed1b86a13444e50dc7a030c10da9 /src/mbgl/style | |
parent | ea8ec38df156c6683c886253dbb1f6bc828686ff (diff) | |
download | qtlocation-mapboxgl-3c175adf30546fe58713b8fed29ac35a85e150be.tar.gz |
[core] split off render layers
Diffstat (limited to 'src/mbgl/style')
35 files changed, 427 insertions, 921 deletions
diff --git a/src/mbgl/style/bucket_parameters.cpp b/src/mbgl/style/bucket_parameters.cpp deleted file mode 100644 index 2b02ac4a4a..0000000000 --- a/src/mbgl/style/bucket_parameters.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include <mbgl/style/bucket_parameters.hpp> - -namespace mbgl { -namespace style { - -} // namespace style -} // namespace mbgl diff --git a/src/mbgl/style/bucket_parameters.hpp b/src/mbgl/style/bucket_parameters.hpp deleted file mode 100644 index d0edbcac30..0000000000 --- a/src/mbgl/style/bucket_parameters.hpp +++ /dev/null @@ -1,16 +0,0 @@ -#pragma once - -#include <mbgl/map/mode.hpp> -#include <mbgl/tile/tile_id.hpp> - -namespace mbgl { -namespace style { - -class BucketParameters { -public: - const OverscaledTileID tileID; - const MapMode mode; -}; - -} // namespace style -} // namespace mbgl diff --git a/src/mbgl/style/group_by_layout.cpp b/src/mbgl/style/group_by_layout.cpp deleted file mode 100644 index b15fe1ca0d..0000000000 --- a/src/mbgl/style/group_by_layout.cpp +++ /dev/null @@ -1,50 +0,0 @@ -#include <mbgl/style/group_by_layout.hpp> -#include <mbgl/style/layer.hpp> -#include <mbgl/style/layer_impl.hpp> -#include <mbgl/style/conversion/stringify.hpp> -#include <mbgl/util/rapidjson.hpp> - -#include <rapidjson/writer.h> -#include <rapidjson/stringbuffer.h> - -#include <unordered_map> - -namespace mbgl { -namespace style { - -std::string layoutKey(const Layer& layer) { - using namespace conversion; - - rapidjson::StringBuffer s; - rapidjson::Writer<rapidjson::StringBuffer> writer(s); - - writer.StartArray(); - writer.Uint(static_cast<uint32_t>(layer.type)); - writer.String(layer.baseImpl->source); - writer.String(layer.baseImpl->sourceLayer); - writer.Double(layer.baseImpl->minZoom); - writer.Double(layer.baseImpl->maxZoom); - writer.Uint(static_cast<uint32_t>(layer.baseImpl->visibility)); - stringify(writer, layer.baseImpl->filter); - layer.baseImpl->stringifyLayout(writer); - writer.EndArray(); - - return s.GetString(); -} - -std::vector<std::vector<const Layer*>> groupByLayout(const std::vector<std::unique_ptr<Layer>>& layers) { - std::unordered_map<std::string, std::vector<const Layer*>> map; - for (auto& layer : layers) { - map[layoutKey(*layer)].push_back(layer.get()); - } - - std::vector<std::vector<const Layer*>> result; - for (auto& pair : map) { - result.push_back(pair.second); - } - - return result; -} - -} // namespace style -} // namespace mbgl diff --git a/src/mbgl/style/group_by_layout.hpp b/src/mbgl/style/group_by_layout.hpp deleted file mode 100644 index 3a89ac95f3..0000000000 --- a/src/mbgl/style/group_by_layout.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include <vector> -#include <memory> - -namespace mbgl { -namespace style { - -class Layer; - -std::vector<std::vector<const Layer*>> groupByLayout(const std::vector<std::unique_ptr<Layer>>&); - -} // namespace style -} // namespace mbgl diff --git a/src/mbgl/style/layer.cpp b/src/mbgl/style/layer.cpp index a78f8c29bc..e2eba0e2e0 100644 --- a/src/mbgl/style/layer.cpp +++ b/src/mbgl/style/layer.cpp @@ -1,10 +1,11 @@ #include <mbgl/style/layer.hpp> #include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layer_type.hpp> namespace mbgl { namespace style { -Layer::Layer(Type type_, std::unique_ptr<Impl> baseImpl_) +Layer::Layer(LayerType type_, std::unique_ptr<Impl> baseImpl_) : type(type_), baseImpl(std::move(baseImpl_)) { } diff --git a/src/mbgl/style/layer_impl.cpp b/src/mbgl/style/layer_impl.cpp index 5840318724..44b1a8dd62 100644 --- a/src/mbgl/style/layer_impl.cpp +++ b/src/mbgl/style/layer_impl.cpp @@ -11,17 +11,6 @@ std::unique_ptr<Layer> Layer::Impl::copy(const std::string& id_, return result; } -bool Layer::Impl::hasRenderPass(RenderPass pass) const { - return bool(passes & pass); -} - -bool Layer::Impl::needsRendering(float zoom) const { - return passes != RenderPass::None - && visibility != VisibilityType::None - && minZoom <= zoom - && maxZoom >= zoom; -} - void Layer::Impl::setObserver(LayerObserver* observer_) { observer = observer_; } diff --git a/src/mbgl/style/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp index 5179192c94..6aa8fccaf0 100644 --- a/src/mbgl/style/layer_impl.hpp +++ b/src/mbgl/style/layer_impl.hpp @@ -4,9 +4,7 @@ #include <mbgl/style/types.hpp> #include <mbgl/style/filter.hpp> #include <mbgl/style/layer_observer.hpp> -#include <mbgl/renderer/render_pass.hpp> #include <mbgl/util/noncopyable.hpp> -#include <mbgl/tile/geometry_tile_data.hpp> #include <rapidjson/writer.h> #include <rapidjson/stringbuffer.h> @@ -17,14 +15,10 @@ namespace mbgl { -class Bucket; +class RenderLayer; namespace style { -class CascadeParameters; -class PropertyEvaluationParameters; -class BucketParameters; - /** * `Layer::Impl` contains the internal implementation of `Layer`: the details that need to be accessible to other parts * of the code, but hidden from the public API. Like `Layer`, it is an abstract base class, with derived classes for @@ -54,27 +48,7 @@ public: // Utility function for automatic layer grouping. virtual void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const = 0; - // Partially evaluate paint properties based on a set of classes. - virtual void cascade(const CascadeParameters&) = 0; - - // Fully evaluate cascaded paint properties based on a zoom level. - // Returns true if any paint properties have active transitions. - virtual bool evaluate(const PropertyEvaluationParameters&) = 0; - - virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const Layer*>&) const = 0; - - // Checks whether this layer needs to be rendered in the given render pass. - bool hasRenderPass(RenderPass) const; - - // Checks whether this layer can be rendered. - bool needsRendering(float zoom) const; - - virtual bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const float, - const float) const { return false; }; + virtual std::unique_ptr<RenderLayer> createRenderLayer() const = 0; void setObserver(LayerObserver*); @@ -94,10 +68,6 @@ protected: Impl() = default; Impl(const Impl&) = default; Impl& operator=(const Impl&) = delete; - - // Stores what render passes this layer is currently enabled for. This depends on the - // evaluated StyleProperties object and is updated accordingly. - RenderPass passes = RenderPass::None; }; } // namespace style 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; }; diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp index 623acef804..7f7018748c 100644 --- a/src/mbgl/style/paint_property.hpp +++ b/src/mbgl/style/paint_property.hpp @@ -203,62 +203,44 @@ public: class Unevaluated : public Tuple<UnevaluatedTypes> { public: using Tuple<UnevaluatedTypes>::Tuple; - }; - class Cascading : public Tuple<CascadingTypes> { - public: - using Tuple<CascadingTypes>::Tuple; - }; - - template <class P> - auto get(const optional<std::string>& klass) const { - return cascading.template get<P>().get(klass); - } - - template <class P> - void set(const typename P::ValueType& value, const optional<std::string>& klass) { - cascading.template get<P>().set(value, klass); - } + bool hasTransition() const { + bool result = false; + util::ignore({ result |= this->template get<Ps>().hasTransition()... }); + return result; + } - template <class P> - void setTransition(const TransitionOptions& value, const optional<std::string>& klass) { - cascading.template get<P>().setTransition(value, klass); - } - - template <class P> - auto getTransition(const optional<std::string>& klass) const { - return cascading.template get<P>().getTransition(klass); - } + template <class P> + auto evaluate(const PropertyEvaluationParameters& parameters) { + using Evaluator = typename P::EvaluatorType; - void cascade(const CascadeParameters& parameters) { - unevaluated = Unevaluated { - cascading.template get<Ps>().cascade(parameters, - std::move(unevaluated.template get<Ps>()))... - }; - } + return this->template get<P>().evaluate( + Evaluator(parameters, P::defaultValue()), + parameters.now + ); + } - template <class P> - auto evaluate(const PropertyEvaluationParameters& parameters) { - using Evaluator = typename P::EvaluatorType; - return unevaluated.template get<P>() - .evaluate(Evaluator(parameters, P::defaultValue()), parameters.now); - } + Evaluated evaluate(const PropertyEvaluationParameters& parameters) { + return Evaluated { + evaluate<Ps>(parameters)... + }; + } - void evaluate(const PropertyEvaluationParameters& parameters) { - evaluated = Evaluated { - evaluate<Ps>(parameters)... - }; - } + }; - bool hasTransition() const { - bool result = false; - util::ignore({ result |= unevaluated.template get<Ps>().hasTransition()... }); - return result; - } + class Cascading : public Tuple<CascadingTypes> { + public: + using Tuple<CascadingTypes>::Tuple; - Cascading cascading; - Unevaluated unevaluated; - Evaluated evaluated; + Unevaluated cascade(const CascadeParameters& parameters, Unevaluated&& prior) const { + return Unevaluated { + this->template get<Ps>().cascade( + parameters, + std::move(prior.template get<Ps>()) + )... + }; + } + }; }; } // namespace style diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp index fc1770e9ee..14efd6a07c 100644 --- a/src/mbgl/style/style.cpp +++ b/src/mbgl/style/style.cpp @@ -24,6 +24,14 @@ #include <mbgl/geometry/line_atlas.hpp> #include <mbgl/renderer/render_item.hpp> #include <mbgl/renderer/render_tile.hpp> +#include <mbgl/renderer/render_background_layer.hpp> +#include <mbgl/renderer/render_circle_layer.hpp> +#include <mbgl/renderer/render_custom_layer.hpp> +#include <mbgl/renderer/render_fill_extrusion_layer.hpp> +#include <mbgl/renderer/render_fill_layer.hpp> +#include <mbgl/renderer/render_line_layer.hpp> +#include <mbgl/renderer/render_raster_layer.hpp> +#include <mbgl/renderer/render_symbol_layer.hpp> #include <mbgl/util/constants.hpp> #include <mbgl/util/exception.hpp> #include <mbgl/util/geometry.hpp> @@ -104,6 +112,7 @@ TransitionOptions Style::getTransitionOptions() const { void Style::setJSON(const std::string& json) { sources.clear(); layers.clear(); + renderLayers.clear(); classes.clear(); transitionOptions = {}; updateBatch = {}; @@ -226,7 +235,9 @@ Layer* Style::addLayer(std::unique_ptr<Layer> layer, optional<std::string> befor layer->baseImpl->setObserver(this); - return layers.emplace(before ? findLayer(*before) : layers.end(), std::move(layer))->get(); + auto added = layers.emplace(before ? findLayer(*before) : layers.end(), std::move(layer))->get(); + renderLayers.emplace(before ? findRenderLayer(*before) : renderLayers.end(), added->baseImpl->createRenderLayer()); + return std::move(added); } std::unique_ptr<Layer> Style::removeLayer(const std::string& id) { @@ -244,9 +255,49 @@ std::unique_ptr<Layer> Style::removeLayer(const std::string& id) { } layers.erase(it); + removeRenderLayer(id); return layer; } +std::vector<const RenderLayer*> Style::getRenderLayers() const { + std::vector<const RenderLayer*> result; + result.reserve(renderLayers.size()); + for (const auto& layer : renderLayers) { + result.push_back(layer.get()); + } + return result; +} + +std::vector<RenderLayer*> Style::getRenderLayers() { + std::vector<RenderLayer*> result; + result.reserve(renderLayers.size()); + for (auto& layer : renderLayers) { + result.push_back(layer.get()); + } + return result; +} + +std::vector<std::unique_ptr<RenderLayer>>::const_iterator Style::findRenderLayer(const std::string& id) const { + return std::find_if(renderLayers.begin(), renderLayers.end(), [&](const auto& layer) { + return layer->baseImpl.id == id; + }); +} + +RenderLayer* Style::getRenderLayer(const std::string& id) const { + auto it = findRenderLayer(id); + return it != renderLayers.end() ? it->get() : nullptr; +} + +void Style::removeRenderLayer(const std::string& id) { + auto it = std::find_if(renderLayers.begin(), renderLayers.end(), [&](const auto& layer) { + return layer->baseImpl.id == id; + }); + + if (it != renderLayers.end()) { + renderLayers.erase(it); + } +} + std::string Style::getName() const { return name; } @@ -304,8 +355,8 @@ void Style::cascade(const TimePoint& timePoint, MapMode mode) { mode == MapMode::Continuous ? transitionOptions : immediateTransition }; - for (const auto& layer : layers) { - layer->baseImpl->cascade(parameters); + for (const auto& layer : renderLayers) { + layer->cascade(parameters); } } @@ -326,17 +377,17 @@ void Style::recalculate(float z, const TimePoint& timePoint, MapMode mode) { }; hasPendingTransitions = false; - for (const auto& layer : layers) { - hasPendingTransitions |= layer->baseImpl->evaluate(parameters); + for (const auto& layer : renderLayers) { + hasPendingTransitions |= layer->evaluate(parameters); // Disable this layer if it doesn't need to be rendered. - const bool needsRendering = layer->baseImpl->needsRendering(zoomHistory.lastZoom); + const bool needsRendering = layer->needsRendering(zoomHistory.lastZoom); if (!needsRendering) { continue; } // If this layer has a source, make sure that it gets loaded. - if (Source* source = getSource(layer->baseImpl->source)) { + if (Source* source = getSource(layer->baseImpl.source)) { source->baseImpl->enabled = true; if (!source->baseImpl->loaded) { source->baseImpl->loadDescription(fileSource); @@ -409,19 +460,19 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const } } - for (const auto& layer : layers) { - if (!layer->baseImpl->needsRendering(zoomHistory.lastZoom)) { + for (const auto& layer : renderLayers) { + if (!layer->needsRendering(zoomHistory.lastZoom)) { continue; } - if (const BackgroundLayer* background = layer->as<BackgroundLayer>()) { + if (const RenderBackgroundLayer* background = layer->as<RenderBackgroundLayer>()) { if (debugOptions & MapDebugOptions::Overdraw) { // We want to skip glClear optimization in overdraw mode. result.order.emplace_back(*layer); continue; } - const BackgroundPaintProperties::Evaluated& paint = background->impl->paint.evaluated; - if (layer.get() == layers[0].get() && paint.get<BackgroundPattern>().from.empty()) { + const BackgroundPaintProperties::Evaluated& paint = background->evaluated; + if (layer.get() == renderLayers[0].get() && paint.get<BackgroundPattern>().from.empty()) { // This is a solid background. We can use glClear(). result.backgroundColor = paint.get<BackgroundColor>() * paint.get<BackgroundOpacity>(); } else { @@ -431,19 +482,19 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const continue; } - if (layer->is<CustomLayer>()) { + if (layer->is<RenderCustomLayer>()) { result.order.emplace_back(*layer); continue; } - Source* source = getSource(layer->baseImpl->source); + Source* source = getSource(layer->baseImpl.source); if (!source) { - Log::Warning(Event::Render, "can't find source for layer '%s'", layer->baseImpl->id.c_str()); + Log::Warning(Event::Render, "can't find source for layer '%s'", layer->baseImpl.id.c_str()); continue; } auto& renderTiles = source->baseImpl->getRenderTiles(); - const bool symbolLayer = layer->is<SymbolLayer>(); + const bool symbolLayer = layer->is<RenderSymbolLayer>(); // Sort symbol tiles in opposite y position, so tiles with overlapping // symbols are drawn on top of each other, with lower symbols being @@ -529,11 +580,11 @@ std::vector<Feature> Style::queryRenderedFeatures(const ScreenLineString& geomet } // Combine all results based on the style layer order. - for (const auto& layer : layers) { - if (!layer->baseImpl->needsRendering(zoomHistory.lastZoom)) { + for (const auto& layer : renderLayers) { + if (!layer->needsRendering(zoomHistory.lastZoom)) { continue; } - auto it = resultsByLayer.find(layer->baseImpl->id); + auto it = resultsByLayer.find(layer->baseImpl.id); if (it != resultsByLayer.end()) { std::move(it->second.begin(), it->second.end(), std::back_inserter(result)); } diff --git a/src/mbgl/style/style.hpp b/src/mbgl/style/style.hpp index 13097fbad8..127430a89f 100644 --- a/src/mbgl/style/style.hpp +++ b/src/mbgl/style/style.hpp @@ -5,6 +5,7 @@ #include <mbgl/style/source_observer.hpp> #include <mbgl/style/layer_observer.hpp> #include <mbgl/style/update_batch.hpp> +#include <mbgl/renderer/render_layer.hpp> #include <mbgl/text/glyph_atlas_observer.hpp> #include <mbgl/sprite/sprite_atlas_observer.hpp> #include <mbgl/map/mode.hpp> @@ -31,6 +32,7 @@ class RenderData; class TransformState; class RenderedQueryOptions; class Scheduler; +class RenderLayer; namespace style { @@ -80,6 +82,11 @@ public: optional<std::string> beforeLayerID = {}); std::unique_ptr<Layer> removeLayer(const std::string& layerID); + // Should be moved to Impl eventually + std::vector<const RenderLayer*> getRenderLayers() const; + std::vector<RenderLayer*> getRenderLayers(); + RenderLayer* getRenderLayer(const std::string& id) const; + std::string getName() const; LatLng getDefaultLatLng() const; double getDefaultZoom() const; @@ -116,6 +123,7 @@ public: private: std::vector<std::unique_ptr<Source>> sources; std::vector<std::unique_ptr<Layer>> layers; + std::vector<std::unique_ptr<RenderLayer>> renderLayers; std::vector<std::string> classes; TransitionOptions transitionOptions; @@ -127,6 +135,7 @@ private: double defaultPitch = 0; std::vector<std::unique_ptr<Layer>>::const_iterator findLayer(const std::string& layerID) const; + std::vector<std::unique_ptr<RenderLayer>>::const_iterator findRenderLayer(const std::string&) const; void reloadLayerSource(Layer&); // GlyphStoreObserver implementation. @@ -161,6 +170,7 @@ private: ZoomHistory zoomHistory; bool hasPendingTransitions = false; + void removeRenderLayer(const std::string& layerID); public: bool loaded = false; }; |