From 3c175adf30546fe58713b8fed29ac35a85e150be Mon Sep 17 00:00:00 2001 From: Ivo van Dongen Date: Fri, 21 Apr 2017 09:19:47 -0700 Subject: [core] split off render layers --- src/mbgl/geometry/feature_index.cpp | 19 ++-- src/mbgl/layout/symbol_layout.cpp | 17 +-- src/mbgl/layout/symbol_layout.hpp | 9 +- src/mbgl/programs/symbol_program.hpp | 1 + src/mbgl/renderer/bucket.hpp | 5 +- src/mbgl/renderer/bucket_parameters.cpp | 5 + src/mbgl/renderer/bucket_parameters.hpp | 14 +++ src/mbgl/renderer/circle_bucket.cpp | 24 ++--- src/mbgl/renderer/circle_bucket.hpp | 8 +- src/mbgl/renderer/fill_bucket.cpp | 18 ++-- src/mbgl/renderer/fill_bucket.hpp | 8 +- src/mbgl/renderer/group_by_layout.cpp | 48 +++++++++ src/mbgl/renderer/group_by_layout.hpp | 12 +++ src/mbgl/renderer/line_bucket.cpp | 29 +++-- src/mbgl/renderer/line_bucket.hpp | 14 ++- src/mbgl/renderer/painter.cpp | 20 ++-- src/mbgl/renderer/painter.hpp | 25 ++--- src/mbgl/renderer/painter_background.cpp | 6 +- src/mbgl/renderer/painter_circle.cpp | 6 +- src/mbgl/renderer/painter_fill.cpp | 12 +-- src/mbgl/renderer/painter_line.cpp | 8 +- src/mbgl/renderer/painter_raster.cpp | 6 +- src/mbgl/renderer/painter_symbol.cpp | 12 +-- src/mbgl/renderer/raster_bucket.cpp | 6 +- src/mbgl/renderer/raster_bucket.hpp | 2 +- src/mbgl/renderer/render_background_layer.cpp | 35 ++++++ src/mbgl/renderer/render_background_layer.hpp | 34 ++++++ src/mbgl/renderer/render_circle_layer.cpp | 65 ++++++++++++ src/mbgl/renderer/render_circle_layer.hpp | 41 +++++++ src/mbgl/renderer/render_custom_layer.cpp | 26 +++++ src/mbgl/renderer/render_custom_layer.hpp | 29 +++++ src/mbgl/renderer/render_fill_extrusion_layer.cpp | 26 +++++ src/mbgl/renderer/render_fill_extrusion_layer.hpp | 32 ++++++ src/mbgl/renderer/render_fill_layer.cpp | 70 ++++++++++++ src/mbgl/renderer/render_fill_layer.hpp | 41 +++++++ src/mbgl/renderer/render_item.hpp | 6 +- src/mbgl/renderer/render_layer.cpp | 25 +++++ src/mbgl/renderer/render_layer.hpp | 87 +++++++++++++++ src/mbgl/renderer/render_line_layer.cpp | 114 ++++++++++++++++++++ src/mbgl/renderer/render_line_layer.hpp | 48 +++++++++ src/mbgl/renderer/render_raster_layer.cpp | 33 ++++++ src/mbgl/renderer/render_raster_layer.hpp | 34 ++++++ src/mbgl/renderer/render_symbol_layer.cpp | 113 ++++++++++++++++++++ src/mbgl/renderer/render_symbol_layer.hpp | 97 +++++++++++++++++ src/mbgl/renderer/symbol_bucket.cpp | 8 +- src/mbgl/renderer/symbol_bucket.hpp | 2 +- src/mbgl/style/bucket_parameters.cpp | 7 -- src/mbgl/style/bucket_parameters.hpp | 16 --- src/mbgl/style/group_by_layout.cpp | 50 --------- src/mbgl/style/group_by_layout.hpp | 14 --- src/mbgl/style/layer.cpp | 3 +- src/mbgl/style/layer_impl.cpp | 11 -- src/mbgl/style/layer_impl.hpp | 34 +----- src/mbgl/style/layers/background_layer.cpp | 30 +++--- src/mbgl/style/layers/background_layer_impl.cpp | 19 +--- src/mbgl/style/layers/background_layer_impl.hpp | 7 +- src/mbgl/style/layers/circle_layer.cpp | 86 +++++++-------- src/mbgl/style/layers/circle_layer_impl.cpp | 47 +------- src/mbgl/style/layers/circle_layer_impl.hpp | 14 +-- src/mbgl/style/layers/custom_layer.cpp | 8 +- src/mbgl/style/layers/custom_layer_impl.cpp | 23 ++-- src/mbgl/style/layers/custom_layer_impl.hpp | 5 +- src/mbgl/style/layers/fill_extrusion_layer.cpp | 62 +++++------ .../style/layers/fill_extrusion_layer_impl.cpp | 13 +-- .../style/layers/fill_extrusion_layer_impl.hpp | 7 +- src/mbgl/style/layers/fill_layer.cpp | 62 +++++------ src/mbgl/style/layers/fill_layer_impl.cpp | 50 +-------- src/mbgl/style/layers/fill_layer_impl.hpp | 14 +-- src/mbgl/style/layers/layer.cpp.ejs | 16 +-- src/mbgl/style/layers/line_layer.cpp | 86 +++++++-------- src/mbgl/style/layers/line_layer_impl.cpp | 97 +---------------- src/mbgl/style/layers/line_layer_impl.hpp | 20 +--- src/mbgl/style/layers/raster_layer.cpp | 62 +++++------ src/mbgl/style/layers/raster_layer_impl.cpp | 19 +--- src/mbgl/style/layers/raster_layer_impl.hpp | 7 +- src/mbgl/style/layers/symbol_layer.cpp | 118 ++++++++++----------- src/mbgl/style/layers/symbol_layer_impl.cpp | 96 +---------------- src/mbgl/style/layers/symbol_layer_impl.hpp | 66 +----------- src/mbgl/style/paint_property.hpp | 80 ++++++-------- src/mbgl/style/style.cpp | 89 ++++++++++++---- src/mbgl/style/style.hpp | 10 ++ src/mbgl/tile/geometry_tile.cpp | 10 +- src/mbgl/tile/geometry_tile.hpp | 4 +- src/mbgl/tile/geometry_tile_worker.cpp | 47 ++++++-- src/mbgl/tile/geometry_tile_worker.hpp | 1 + src/mbgl/tile/raster_tile.cpp | 2 +- src/mbgl/tile/raster_tile.hpp | 2 +- src/mbgl/tile/tile.hpp | 4 +- 88 files changed, 1638 insertions(+), 1080 deletions(-) create mode 100644 src/mbgl/renderer/bucket_parameters.cpp create mode 100644 src/mbgl/renderer/bucket_parameters.hpp create mode 100644 src/mbgl/renderer/group_by_layout.cpp create mode 100644 src/mbgl/renderer/group_by_layout.hpp create mode 100644 src/mbgl/renderer/render_background_layer.cpp create mode 100644 src/mbgl/renderer/render_background_layer.hpp create mode 100644 src/mbgl/renderer/render_circle_layer.cpp create mode 100644 src/mbgl/renderer/render_circle_layer.hpp create mode 100644 src/mbgl/renderer/render_custom_layer.cpp create mode 100644 src/mbgl/renderer/render_custom_layer.hpp create mode 100644 src/mbgl/renderer/render_fill_extrusion_layer.cpp create mode 100644 src/mbgl/renderer/render_fill_extrusion_layer.hpp create mode 100644 src/mbgl/renderer/render_fill_layer.cpp create mode 100644 src/mbgl/renderer/render_fill_layer.hpp create mode 100644 src/mbgl/renderer/render_layer.cpp create mode 100644 src/mbgl/renderer/render_layer.hpp create mode 100644 src/mbgl/renderer/render_line_layer.cpp create mode 100644 src/mbgl/renderer/render_line_layer.hpp create mode 100644 src/mbgl/renderer/render_raster_layer.cpp create mode 100644 src/mbgl/renderer/render_raster_layer.hpp create mode 100644 src/mbgl/renderer/render_symbol_layer.cpp create mode 100644 src/mbgl/renderer/render_symbol_layer.hpp delete mode 100644 src/mbgl/style/bucket_parameters.cpp delete mode 100644 src/mbgl/style/bucket_parameters.hpp delete mode 100644 src/mbgl/style/group_by_layout.cpp delete mode 100644 src/mbgl/style/group_by_layout.hpp (limited to 'src/mbgl') diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp index 6fae5fe9a1..8251e4d03a 100644 --- a/src/mbgl/geometry/feature_index.cpp +++ b/src/mbgl/geometry/feature_index.cpp @@ -1,8 +1,7 @@ #include #include -#include -#include -#include +#include +#include #include #include #include @@ -61,7 +60,7 @@ static int16_t getAdditionalQueryRadius(const RenderedQueryOptions& queryOptions // Determine the additional radius needed factoring in property functions float additionalRadius = 0; - auto getQueryRadius = [&](const style::Layer& layer) { + auto getQueryRadius = [&](const RenderLayer& layer) { auto bucket = tile.getBucket(layer); if (bucket) { additionalRadius = std::max(additionalRadius, bucket->getQueryRadius(layer) * pixelsToTileUnits); @@ -70,13 +69,13 @@ static int16_t getAdditionalQueryRadius(const RenderedQueryOptions& queryOptions if (queryOptions.layerIDs) { for (const auto& layerID : *queryOptions.layerIDs) { - style::Layer* layer = style.getLayer(layerID); + RenderLayer* layer = style.getRenderLayer(layerID); if (layer) { getQueryRadius(*layer); } } } else { - for (const style::Layer* layer : style.getLayers()) { + for (const RenderLayer* layer : style.getRenderLayers()) { getQueryRadius(*layer); } } @@ -156,10 +155,10 @@ void FeatureIndex::addFeature( continue; } - auto styleLayer = style.getLayer(layerID); - if (!styleLayer || - (!styleLayer->is() && - !styleLayer->baseImpl->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, bearing, pixelsToTileUnits))) { + auto renderLayer = style.getRenderLayer(layerID); + if (!renderLayer || + (!renderLayer->is() && + !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, bearing, pixelsToTileUnits))) { continue; } diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp index 0b05d4f5e1..9aca316a00 100644 --- a/src/mbgl/layout/symbol_layout.cpp +++ b/src/mbgl/layout/symbol_layout.cpp @@ -3,8 +3,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -22,6 +22,7 @@ #include #include #include +#include #include @@ -38,7 +39,7 @@ static bool has(const style::SymbolLayoutProperties::PossiblyEvaluated& layout) } SymbolLayout::SymbolLayout(const BucketParameters& parameters, - const std::vector& layers, + const std::vector& layers, const GeometryTileLayer& sourceLayer, IconDependencies& iconDependencies, uintptr_t _spriteAtlasMapIndex, @@ -51,11 +52,11 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters, spriteAtlasMapIndex(_spriteAtlasMapIndex), tileSize(util::tileSize * overscaling), tilePixelRatio(float(util::EXTENT) / tileSize), - textSize(layers.at(0)->as()->impl->layout.unevaluated.get()), - iconSize(layers.at(0)->as()->impl->layout.unevaluated.get()) + textSize(layers.at(0)->as()->impl->layout.unevaluated.get()), + iconSize(layers.at(0)->as()->impl->layout.unevaluated.get()) { - const SymbolLayer::Impl& leader = *layers.at(0)->as()->impl; + const SymbolLayer::Impl& leader = *layers.at(0)->as()->impl; layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom)); @@ -89,8 +90,8 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters, for (const auto& layer : layers) { layerPaintProperties.emplace(layer->getID(), std::make_pair( - layer->as()->impl->iconPaintProperties(), - layer->as()->impl->textPaintProperties() + layer->as()->iconPaintProperties(), + layer->as()->textPaintProperties() )); } diff --git a/src/mbgl/layout/symbol_layout.hpp b/src/mbgl/layout/symbol_layout.hpp index f49f93eaf1..55e4098451 100644 --- a/src/mbgl/layout/symbol_layout.hpp +++ b/src/mbgl/layout/symbol_layout.hpp @@ -15,21 +15,20 @@ namespace mbgl { -class GeometryTileLayer; +class BucketParameters; class CollisionTile; class SymbolBucket; class Anchor; +class RenderLayer; namespace style { -class BucketParameters; class Filter; -class Layer; } // namespace style class SymbolLayout { public: - SymbolLayout(const style::BucketParameters&, - const std::vector&, + SymbolLayout(const BucketParameters&, + const std::vector&, const GeometryTileLayer&, IconDependencies&, uintptr_t, diff --git a/src/mbgl/programs/symbol_program.hpp b/src/mbgl/programs/symbol_program.hpp index ae50e790be..4895f6fca7 100644 --- a/src/mbgl/programs/symbol_program.hpp +++ b/src/mbgl/programs/symbol_program.hpp @@ -13,6 +13,7 @@ #include #include #include +#include #include diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 84ecabe632..6c391cf014 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -36,11 +37,11 @@ public: // Every time this bucket is getting rendered, this function is called. This happens either // once or twice (for Opaque and Transparent render passes). - virtual void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) = 0; + virtual void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) = 0; virtual bool hasData() const = 0; - virtual float getQueryRadius(const style::Layer&) const { + virtual float getQueryRadius(const RenderLayer&) const { return 0; }; diff --git a/src/mbgl/renderer/bucket_parameters.cpp b/src/mbgl/renderer/bucket_parameters.cpp new file mode 100644 index 0000000000..35b87bffea --- /dev/null +++ b/src/mbgl/renderer/bucket_parameters.cpp @@ -0,0 +1,5 @@ +#include + +namespace mbgl { + +} // namespace mbgl diff --git a/src/mbgl/renderer/bucket_parameters.hpp b/src/mbgl/renderer/bucket_parameters.hpp new file mode 100644 index 0000000000..1774ba2bbe --- /dev/null +++ b/src/mbgl/renderer/bucket_parameters.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include +#include + +namespace mbgl { + +class BucketParameters { +public: + const OverscaledTileID tileID; + const MapMode mode; +}; + +} // namespace mbgl diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp index 94529a66d8..1e08eca478 100644 --- a/src/mbgl/renderer/circle_bucket.cpp +++ b/src/mbgl/renderer/circle_bucket.cpp @@ -1,9 +1,9 @@ #include +#include #include #include -#include -#include #include +#include #include #include @@ -11,14 +11,14 @@ namespace mbgl { using namespace style; -CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector& layers) +CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector& layers) : mode(parameters.mode) { for (const auto& layer : layers) { paintPropertyBinders.emplace( std::piecewise_construct, std::forward_as_tuple(layer->getID()), std::forward_as_tuple( - layer->as()->impl->paint.evaluated, + layer->as()->evaluated, parameters.tileID.overscaledZ)); } } @@ -36,9 +36,9 @@ void CircleBucket::upload(gl::Context& context) { void CircleBucket::render(Painter& painter, PaintParameters& parameters, - const Layer& layer, + const RenderLayer& layer, const RenderTile& tile) { - painter.renderCircle(parameters, *this, *layer.as(), tile); + painter.renderCircle(parameters, *this, *layer.as(), tile); } bool CircleBucket::hasData() const { @@ -99,24 +99,24 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature, } template -static float get(const CircleLayer& layer, const std::map& paintPropertyBinders) { +static float get(const RenderCircleLayer& layer, const std::map& paintPropertyBinders) { auto it = paintPropertyBinders.find(layer.getID()); if (it == paintPropertyBinders.end() || !it->second.statistics().max()) { - return layer.impl->paint.evaluated.get().constantOr(Property::defaultValue()); + return layer.evaluated.get().constantOr(Property::defaultValue()); } else { return *it->second.statistics().max(); } } -float CircleBucket::getQueryRadius(const style::Layer& layer) const { - if (!layer.is()) { +float CircleBucket::getQueryRadius(const RenderLayer& layer) const { + if (!layer.is()) { return 0; } - auto circleLayer = layer.as(); + auto circleLayer = layer.as(); float radius = get(*circleLayer, paintPropertyBinders); - auto translate = circleLayer->impl->paint.evaluated.get(); + auto translate = circleLayer->evaluated.get(); return radius + util::length(translate[0], translate[1]); } diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp index 02f60ad2ba..855565ebf4 100644 --- a/src/mbgl/renderer/circle_bucket.hpp +++ b/src/mbgl/renderer/circle_bucket.hpp @@ -11,22 +11,20 @@ namespace mbgl { -namespace style { class BucketParameters; -} // namespace style class CircleBucket : public Bucket { public: - CircleBucket(const style::BucketParameters&, const std::vector&); + CircleBucket(const BucketParameters&, const std::vector&); void addFeature(const GeometryTileFeature&, const GeometryCollection&) override; bool hasData() const override; void upload(gl::Context&) override; - void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) override; + void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override; - float getQueryRadius(const style::Layer&) const override; + float getQueryRadius(const RenderLayer&) const override; gl::VertexVector vertices; gl::IndexVector triangles; diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index 53bf825d48..2409fd365b 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -1,9 +1,9 @@ #include #include #include -#include -#include +#include #include +#include #include #include @@ -28,13 +28,13 @@ using namespace style; struct GeometryTooLongException : std::exception {}; -FillBucket::FillBucket(const BucketParameters& parameters, const std::vector& layers) { +FillBucket::FillBucket(const BucketParameters& parameters, const std::vector& layers) { for (const auto& layer : layers) { paintPropertyBinders.emplace( std::piecewise_construct, std::forward_as_tuple(layer->getID()), std::forward_as_tuple( - layer->as()->impl->paint.evaluated, + layer->as()->evaluated, parameters.tileID.overscaledZ)); } } @@ -123,21 +123,21 @@ void FillBucket::upload(gl::Context& context) { void FillBucket::render(Painter& painter, PaintParameters& parameters, - const Layer& layer, + const RenderLayer& layer, const RenderTile& tile) { - painter.renderFill(parameters, *this, *layer.as(), tile); + painter.renderFill(parameters, *this, *layer.as(), tile); } bool FillBucket::hasData() const { return !triangleSegments.empty() || !lineSegments.empty(); } -float FillBucket::getQueryRadius(const style::Layer& layer) const { - if (!layer.is()) { +float FillBucket::getQueryRadius(const RenderLayer& layer) const { + if (!layer.is()) { return 0; } - const std::array& translate = layer.as()->impl->paint.evaluated.get(); + const std::array& translate = layer.as()->evaluated.get(); return util::length(translate[0], translate[1]); } diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index e96cd2ac5e..421d8b332b 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -12,22 +12,20 @@ namespace mbgl { -namespace style { class BucketParameters; -} // namespace style class FillBucket : public Bucket { public: - FillBucket(const style::BucketParameters&, const std::vector&); + FillBucket(const BucketParameters&, const std::vector&); void addFeature(const GeometryTileFeature&, const GeometryCollection&) override; bool hasData() const override; void upload(gl::Context&) override; - void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) override; + void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override; - float getQueryRadius(const style::Layer&) const override; + float getQueryRadius(const RenderLayer&) const override; gl::VertexVector vertices; gl::IndexVector lines; diff --git a/src/mbgl/renderer/group_by_layout.cpp b/src/mbgl/renderer/group_by_layout.cpp new file mode 100644 index 0000000000..df1eb7c7dd --- /dev/null +++ b/src/mbgl/renderer/group_by_layout.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +#include +#include + +#include +#include + +#include + +namespace mbgl { + +std::string layoutKey(const RenderLayer& layer) { + using namespace style::conversion; + + rapidjson::StringBuffer s; + rapidjson::Writer writer(s); + + writer.StartArray(); + writer.Uint(static_cast(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(layer.baseImpl.visibility)); + stringify(writer, layer.baseImpl.filter); + layer.baseImpl.stringifyLayout(writer); + writer.EndArray(); + + return s.GetString(); +} + +std::vector> groupByLayout(const std::vector>& layers) { + std::unordered_map> map; + for (auto& layer : layers) { + map[layoutKey(*layer)].push_back(layer.get()); + } + + std::vector> result; + for (auto& pair : map) { + result.push_back(pair.second); + } + + return result; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/group_by_layout.hpp b/src/mbgl/renderer/group_by_layout.hpp new file mode 100644 index 0000000000..bc3ecfae63 --- /dev/null +++ b/src/mbgl/renderer/group_by_layout.hpp @@ -0,0 +1,12 @@ +#pragma once + +#include +#include + +namespace mbgl { + +class RenderLayer; + +std::vector> groupByLayout(const std::vector>&); + +} // namespace mbgl diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp index 8c56524020..7bb4e2f202 100644 --- a/src/mbgl/renderer/line_bucket.cpp +++ b/src/mbgl/renderer/line_bucket.cpp @@ -1,7 +1,7 @@ #include #include -#include -#include +#include +#include #include #include #include @@ -13,7 +13,7 @@ namespace mbgl { using namespace style; LineBucket::LineBucket(const BucketParameters& parameters, - const std::vector& layers, + const std::vector& layers, const style::LineLayoutProperties& layout_) : layout(layout_.evaluate(PropertyEvaluationParameters(parameters.tileID.overscaledZ))), overscaling(parameters.tileID.overscaleFactor()) { @@ -22,7 +22,7 @@ LineBucket::LineBucket(const BucketParameters& parameters, std::piecewise_construct, std::forward_as_tuple(layer->getID()), std::forward_as_tuple( - layer->as()->impl->paint.evaluated, + layer->as()->evaluated, parameters.tileID.overscaledZ)); } } @@ -460,9 +460,9 @@ void LineBucket::upload(gl::Context& context) { void LineBucket::render(Painter& painter, PaintParameters& parameters, - const Layer& layer, + const RenderLayer& layer, const RenderTile& tile) { - painter.renderLine(parameters, *this, *layer.as(), tile); + painter.renderLine(parameters, *this, *layer.as(), tile); } bool LineBucket::hasData() const { @@ -470,17 +470,17 @@ bool LineBucket::hasData() const { } template -static float get(const LineLayer& layer, const std::map& paintPropertyBinders) { +static float get(const RenderLineLayer& layer, const std::map& paintPropertyBinders) { auto it = paintPropertyBinders.find(layer.getID()); if (it == paintPropertyBinders.end() || !it->second.statistics().max()) { - return layer.impl->paint.evaluated.get().constantOr(Property::defaultValue()); + return layer.evaluated.get().constantOr(Property::defaultValue()); } else { return *it->second.statistics().max(); } } -float LineBucket::getLineWidth(const style::LineLayer& layer) const { - float lineWidth = layer.impl->paint.evaluated.get(); +float LineBucket::getLineWidth(const RenderLineLayer& layer) const { + float lineWidth = layer.evaluated.get(); float gapWidth = get(layer, paintPropertyBinders); if (gapWidth) { @@ -490,15 +490,14 @@ float LineBucket::getLineWidth(const style::LineLayer& layer) const { } } -float LineBucket::getQueryRadius(const style::Layer& layer) const { - if (!layer.is()) { +float LineBucket::getQueryRadius(const RenderLayer& layer) const { + if (!layer.is()) { return 0; } - auto lineLayer = layer.as(); - auto paint = lineLayer->impl->paint; + auto lineLayer = layer.as(); - const std::array& translate = paint.evaluated.get(); + const std::array& translate = lineLayer->evaluated.get(); float offset = get(*lineLayer, paintPropertyBinders); return getLineWidth(*lineLayer) / 2.0 + std::abs(offset) + util::length(translate[0], translate[1]); } diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 30198305ad..c319548714 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -12,15 +12,13 @@ namespace mbgl { -namespace style { class BucketParameters; -class LineLayer; -} // namespace style +class RenderLineLayer; class LineBucket : public Bucket { public: - LineBucket(const style::BucketParameters&, - const std::vector&, + LineBucket(const BucketParameters&, + const std::vector&, const style::LineLayoutProperties&); void addFeature(const GeometryTileFeature&, @@ -28,9 +26,9 @@ public: bool hasData() const override; void upload(gl::Context&) override; - void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) override; + void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override; - float getQueryRadius(const style::Layer&) const override; + float getQueryRadius(const RenderLayer&) const override; style::LineLayoutProperties::PossiblyEvaluated layout; @@ -63,7 +61,7 @@ private: const uint32_t overscaling; - float getLineWidth(const style::LineLayer& layer) const; + float getLineWidth(const RenderLineLayer& layer) const; }; } // namespace mbgl diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index f7a498ecae..0c4915d3e9 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -13,8 +13,8 @@ #include #include -#include -#include +#include +#include #include #include @@ -279,16 +279,16 @@ void Painter::renderPass(PaintParameters& parameters, currentLayer = i; const auto& item = *it; - const Layer& layer = item.layer; + const RenderLayer& layer = item.layer; - if (!layer.baseImpl->hasRenderPass(pass)) + if (!layer.hasRenderPass(pass)) continue; - if (layer.is()) { + if (layer.is()) { MBGL_DEBUG_GROUP(context, "background"); - renderBackground(parameters, *layer.as()); - } else if (layer.is()) { - MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - custom"); + renderBackground(parameters, *layer.as()); + } else if (layer.is()) { + MBGL_DEBUG_GROUP(context, layer.baseImpl.id + " - custom"); // Reset GL state to a known state so the CustomLayer always has a clean slate. context.vertexArrayObject = 0; @@ -296,14 +296,14 @@ void Painter::renderPass(PaintParameters& parameters, context.setStencilMode(gl::StencilMode::disabled()); context.setColorMode(colorModeForRenderPass()); - layer.as()->impl->render(state); + layer.as()->impl->render(state); // Reset the view back to our original one, just in case the CustomLayer changed // the viewport or Framebuffer. parameters.view.bind(); context.setDirtyState(); } else { - MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - " + util::toString(item.tile->id)); + MBGL_DEBUG_GROUP(context, layer.baseImpl.id + " - " + util::toString(item.tile->id)); item.bucket->render(*this, parameters, layer, *item.tile); } } diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index 3dcc1d5d46..9c6dd4505f 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -42,6 +42,13 @@ class CircleBucket; class SymbolBucket; class RasterBucket; +class RenderFillLayer; +class RenderLineLayer; +class RenderCircleLayer; +class RenderSymbolLayer; +class RenderRasterLayer; +class RenderBackgroundLayer; + class Programs; class PaintParameters; @@ -50,12 +57,6 @@ struct ClipID; namespace style { class Style; class Source; -class FillLayer; -class LineLayer; -class CircleLayer; -class SymbolLayer; -class RasterLayer; -class BackgroundLayer; } // namespace style struct FrameData { @@ -80,12 +81,12 @@ public: void renderClippingMask(const UnwrappedTileID&, const ClipID&); void renderTileDebug(const RenderTile&); - void renderFill(PaintParameters&, FillBucket&, const style::FillLayer&, const RenderTile&); - void renderLine(PaintParameters&, LineBucket&, const style::LineLayer&, const RenderTile&); - void renderCircle(PaintParameters&, CircleBucket&, const style::CircleLayer&, const RenderTile&); - void renderSymbol(PaintParameters&, SymbolBucket&, const style::SymbolLayer&, const RenderTile&); - void renderRaster(PaintParameters&, RasterBucket&, const style::RasterLayer&, const RenderTile&); - void renderBackground(PaintParameters&, const style::BackgroundLayer&); + void renderFill(PaintParameters&, FillBucket&, const RenderFillLayer&, const RenderTile&); + void renderLine(PaintParameters&, LineBucket&, const RenderLineLayer&, const RenderTile&); + void renderCircle(PaintParameters&, CircleBucket&, const RenderCircleLayer&, const RenderTile&); + void renderSymbol(PaintParameters&, SymbolBucket&, const RenderSymbolLayer&, const RenderTile&); + void renderRaster(PaintParameters&, RasterBucket&, const RenderRasterLayer&, const RenderTile&); + void renderBackground(PaintParameters&, const RenderBackgroundLayer&); #ifndef NDEBUG // Renders tile clip boundaries, using stencil buffer to calculate fill color. diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp index 4ac414335b..ac16627246 100644 --- a/src/mbgl/renderer/painter_background.cpp +++ b/src/mbgl/renderer/painter_background.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -11,10 +11,10 @@ namespace mbgl { using namespace style; -void Painter::renderBackground(PaintParameters& parameters, const BackgroundLayer& layer) { +void Painter::renderBackground(PaintParameters& parameters, const RenderBackgroundLayer& layer) { // Note that for bottommost layers without a pattern, the background color is drawn with // glClear rather than this method. - const BackgroundPaintProperties::Evaluated& background = layer.impl->paint.evaluated; + const BackgroundPaintProperties::Evaluated& background = layer.evaluated; style::FillPaintProperties::Evaluated properties; properties.get() = background.get(); diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp index 8d47e75f71..7c9194f6dd 100644 --- a/src/mbgl/renderer/painter_circle.cpp +++ b/src/mbgl/renderer/painter_circle.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -14,13 +14,13 @@ using namespace style; void Painter::renderCircle(PaintParameters& parameters, CircleBucket& bucket, - const CircleLayer& layer, + const RenderCircleLayer& layer, const RenderTile& tile) { if (pass == RenderPass::Opaque) { return; } - const CirclePaintProperties::Evaluated& properties = layer.impl->paint.evaluated; + const CirclePaintProperties::Evaluated& properties = layer.evaluated; const bool scaleWithMap = properties.get() == CirclePitchScaleType::Map; parameters.programs.circle.draw( diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp index 4276bd06ed..622f6386ef 100644 --- a/src/mbgl/renderer/painter_fill.cpp +++ b/src/mbgl/renderer/painter_fill.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -15,9 +15,9 @@ using namespace style; void Painter::renderFill(PaintParameters& parameters, FillBucket& bucket, - const FillLayer& layer, + const RenderFillLayer& layer, const RenderTile& tile) { - const FillPaintProperties::Evaluated& properties = layer.impl->paint.evaluated; + const FillPaintProperties::Evaluated& properties = layer.evaluated; if (!properties.get().from.empty()) { if (pass != RenderPass::Translucent) { @@ -70,7 +70,7 @@ void Painter::renderFill(PaintParameters& parameters, *bucket.triangleIndexBuffer, bucket.triangleSegments); - if (!properties.get() || !layer.impl->paint.unevaluated.get().isUndefined()) { + if (!properties.get() || !layer.unevaluated.get().isUndefined()) { return; } @@ -108,7 +108,7 @@ void Painter::renderFill(PaintParameters& parameters, ); }; - if (properties.get() && !layer.impl->paint.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { + if (properties.get() && !layer.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { draw(2, parameters.programs.fillOutline, gl::Lines { 2.0f }, @@ -127,7 +127,7 @@ void Painter::renderFill(PaintParameters& parameters, bucket.triangleSegments); } - if (properties.get() && layer.impl->paint.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { + if (properties.get() && layer.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { draw(2, parameters.programs.fillOutline, gl::Lines { 2.0f }, diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp index 4e19f841b1..4d7a27d0f6 100644 --- a/src/mbgl/renderer/painter_line.cpp +++ b/src/mbgl/renderer/painter_line.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -15,13 +15,13 @@ using namespace style; void Painter::renderLine(PaintParameters& parameters, LineBucket& bucket, - const LineLayer& layer, + const RenderLineLayer& layer, const RenderTile& tile) { if (pass == RenderPass::Opaque) { return; } - const LinePaintProperties::Evaluated& properties = layer.impl->paint.evaluated; + const LinePaintProperties::Evaluated& properties = layer.evaluated; auto draw = [&] (auto& program, auto&& uniformValues) { program.draw( @@ -57,7 +57,7 @@ void Painter::renderLine(PaintParameters& parameters, pixelsToGLUnits, posA, posB, - layer.impl->dashLineWidth, + layer.dashLineWidth, lineAtlas->getSize().width)); } else if (!properties.get().from.empty()) { diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp index c216955db8..31f10ed3ba 100644 --- a/src/mbgl/renderer/painter_raster.cpp +++ b/src/mbgl/renderer/painter_raster.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -41,14 +41,14 @@ static std::array spinWeights(float spin) { void Painter::renderRaster(PaintParameters& parameters, RasterBucket& bucket, - const RasterLayer& layer, + const RenderRasterLayer& layer, const RenderTile& tile) { if (pass != RenderPass::Translucent) return; if (!bucket.hasData()) return; - const RasterPaintProperties::Evaluated& properties = layer.impl->paint.evaluated; + const RasterPaintProperties::Evaluated& properties = layer.evaluated; const RasterProgram::PaintPropertyBinders paintAttributeData(properties, 0); assert(bucket.texture); diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp index d2f492d17a..9bafb5df80 100644 --- a/src/mbgl/renderer/painter_symbol.cpp +++ b/src/mbgl/renderer/painter_symbol.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -20,7 +20,7 @@ using namespace style; void Painter::renderSymbol(PaintParameters& parameters, SymbolBucket& bucket, - const SymbolLayer& layer, + const RenderSymbolLayer& layer, const RenderTile& tile) { if (pass == RenderPass::Opaque) { return; @@ -64,8 +64,8 @@ void Painter::renderSymbol(PaintParameters& parameters, }; if (bucket.hasIconData()) { - auto values = layer.impl->iconPropertyValues(layout); - auto paintPropertyValues = layer.impl->iconPaintProperties(); + auto values = layer.iconPropertyValues(layout); + auto paintPropertyValues = layer.iconPaintProperties(); SpriteAtlas& atlas = *layer.impl->spriteAtlas; const bool iconScaled = layout.get().constantOr(1.0) != 1.0 || @@ -110,8 +110,8 @@ void Painter::renderSymbol(PaintParameters& parameters, if (bucket.hasTextData()) { glyphAtlas->bind(context, 0); - auto values = layer.impl->textPropertyValues(layout); - auto paintPropertyValues = layer.impl->textPaintProperties(); + auto values = layer.textPropertyValues(layout); + auto paintPropertyValues = layer.textPaintProperties(); const Size texsize = glyphAtlas->getSize(); diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index f328ad9313..ee8ef24071 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -18,9 +18,9 @@ void RasterBucket::upload(gl::Context& context) { void RasterBucket::render(Painter& painter, PaintParameters& parameters, - const Layer& layer, + const RenderLayer& layer, const RenderTile& tile) { - painter.renderRaster(parameters, *this, *layer.as(), tile); + painter.renderRaster(parameters, *this, *layer.as(), tile); } bool RasterBucket::hasData() const { diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index 20969cf6b8..334954e3f4 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -12,7 +12,7 @@ public: RasterBucket(UnassociatedImage&&); void upload(gl::Context&) override; - void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) override; + void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override; bool hasData() const override; UnassociatedImage image; diff --git a/src/mbgl/renderer/render_background_layer.cpp b/src/mbgl/renderer/render_background_layer.cpp new file mode 100644 index 0000000000..5b98210975 --- /dev/null +++ b/src/mbgl/renderer/render_background_layer.cpp @@ -0,0 +1,35 @@ +#include +#include +#include + +namespace mbgl { + +RenderBackgroundLayer::RenderBackgroundLayer(const style::BackgroundLayer::Impl& _impl) + : RenderLayer(style::LayerType::Background, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderBackgroundLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderBackgroundLayer::createBucket(const BucketParameters &, + const std::vector &) const { + assert(false); + return nullptr; +} + +void RenderBackgroundLayer::cascade(const style::CascadeParameters ¶meters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderBackgroundLayer::evaluate(const style::PropertyEvaluationParameters ¶meters) { + evaluated = unevaluated.evaluate(parameters); + + passes = evaluated.get() > 0 ? RenderPass::Translucent + : RenderPass::None; + + return unevaluated.hasTransition(); +} + +} diff --git a/src/mbgl/renderer/render_background_layer.hpp b/src/mbgl/renderer/render_background_layer.hpp new file mode 100644 index 0000000000..bd74f7b390 --- /dev/null +++ b/src/mbgl/renderer/render_background_layer.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderBackgroundLayer: public RenderLayer { +public: + + RenderBackgroundLayer(const style::BackgroundLayer::Impl&); + ~RenderBackgroundLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::BackgroundPaintProperties::Unevaluated unevaluated; + style::BackgroundPaintProperties::Evaluated evaluated; + + const style::BackgroundLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Background; +} + +} diff --git a/src/mbgl/renderer/render_circle_layer.cpp b/src/mbgl/renderer/render_circle_layer.cpp new file mode 100644 index 0000000000..aa127e9859 --- /dev/null +++ b/src/mbgl/renderer/render_circle_layer.cpp @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +RenderCircleLayer::RenderCircleLayer(const style::CircleLayer::Impl& _impl) + : RenderLayer(style::LayerType::Circle, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderCircleLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderCircleLayer::createBucket(const BucketParameters& parameters, const std::vector& layers) const { + return std::make_unique(parameters, layers); +} + +void RenderCircleLayer::cascade(const style::CascadeParameters& parameters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderCircleLayer::evaluate(const style::PropertyEvaluationParameters& parameters) { + evaluated = unevaluated.evaluate(parameters); + + passes = ((evaluated.get().constantOr(1) > 0 || + evaluated.get().constantOr(1) > 0) + && (evaluated.get().constantOr(Color::black()).a > 0 || + evaluated.get().constantOr(Color::black()).a > 0) + && (evaluated.get().constantOr(1) > 0 || + evaluated.get().constantOr(1) > 0)) + ? RenderPass::Translucent : RenderPass::None; + + return unevaluated.hasTransition(); +} + +bool RenderCircleLayer::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, + evaluated.get(), + evaluated.get(), + bearing, + pixelsToTileUnits); + + // Evaluate function + auto circleRadius = evaluated.get() + .evaluate(feature, zoom, style::CircleRadius::defaultValue()) + * pixelsToTileUnits; + + // Test intersection + return util::polygonIntersectsBufferedMultiPoint(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries(), circleRadius); +} + +} diff --git a/src/mbgl/renderer/render_circle_layer.hpp b/src/mbgl/renderer/render_circle_layer.hpp new file mode 100644 index 0000000000..5117b12246 --- /dev/null +++ b/src/mbgl/renderer/render_circle_layer.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderCircleLayer: public RenderLayer { +public: + + RenderCircleLayer(const style::CircleLayer::Impl&); + ~RenderCircleLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + bool queryIntersectsFeature( + const GeometryCoordinates&, + const GeometryTileFeature&, + const float, + const float, + const float) const override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::CirclePaintProperties::Unevaluated unevaluated; + style::CirclePaintProperties::Evaluated evaluated; + + const style::CircleLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Circle; +} + +} diff --git a/src/mbgl/renderer/render_custom_layer.cpp b/src/mbgl/renderer/render_custom_layer.cpp new file mode 100644 index 0000000000..f9dda47d7a --- /dev/null +++ b/src/mbgl/renderer/render_custom_layer.cpp @@ -0,0 +1,26 @@ +#include +#include +#include + +namespace mbgl { + +RenderCustomLayer::RenderCustomLayer(const style::CustomLayer::Impl& _impl) + : RenderLayer(style::LayerType::Custom, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderCustomLayer::clone() const { + return std::make_unique(*this); +} + +bool RenderCustomLayer::evaluate(const style::PropertyEvaluationParameters&) { + passes = RenderPass::Translucent; + return false; +} + +std::unique_ptr RenderCustomLayer::createBucket(const BucketParameters&, const std::vector&) const { + assert(false); + return nullptr; +} + +} diff --git a/src/mbgl/renderer/render_custom_layer.hpp b/src/mbgl/renderer/render_custom_layer.hpp new file mode 100644 index 0000000000..3c6c06ff7c --- /dev/null +++ b/src/mbgl/renderer/render_custom_layer.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include + +namespace mbgl { + +class RenderCustomLayer: public RenderLayer { +public: + + RenderCustomLayer(const style::CustomLayer::Impl&); + ~RenderCustomLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) final {} + bool evaluate(const style::PropertyEvaluationParameters&) final; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const final; + + const style::CustomLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Custom; +} + +} diff --git a/src/mbgl/renderer/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/render_fill_extrusion_layer.cpp new file mode 100644 index 0000000000..a378f12cf0 --- /dev/null +++ b/src/mbgl/renderer/render_fill_extrusion_layer.cpp @@ -0,0 +1,26 @@ +#include +#include +#include + +namespace mbgl { + +RenderFillExtrusionLayer::RenderFillExtrusionLayer(const style::FillExtrusionLayer::Impl& _impl) + : RenderLayer(style::LayerType::FillExtrusion, _impl) { +} + +std::unique_ptr RenderFillExtrusionLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderFillExtrusionLayer::createBucket(const BucketParameters&, const std::vector&) const { + return nullptr; +} + +void RenderFillExtrusionLayer::cascade(const style::CascadeParameters&) { +} + +bool RenderFillExtrusionLayer::evaluate(const style::PropertyEvaluationParameters&) { + return false; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/render_fill_extrusion_layer.hpp new file mode 100644 index 0000000000..596ba02fee --- /dev/null +++ b/src/mbgl/renderer/render_fill_extrusion_layer.hpp @@ -0,0 +1,32 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderFillExtrusionLayer: public RenderLayer { +public: + + RenderFillExtrusionLayer(const style::FillExtrusionLayer::Impl&); + ~RenderFillExtrusionLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::FillExtrusionPaintProperties::Unevaluated unevaluated; + style::FillExtrusionPaintProperties::Evaluated evaluated; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::FillExtrusion; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_fill_layer.cpp b/src/mbgl/renderer/render_fill_layer.cpp new file mode 100644 index 0000000000..126189fc50 --- /dev/null +++ b/src/mbgl/renderer/render_fill_layer.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +RenderFillLayer::RenderFillLayer(const style::FillLayer::Impl& _impl) + : RenderLayer(style::LayerType::Fill, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderFillLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderFillLayer::createBucket(const BucketParameters& parameters, const std::vector& layers) const { + return std::make_unique(parameters, layers); +} + +void RenderFillLayer::cascade(const style::CascadeParameters& parameters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderFillLayer::evaluate(const style::PropertyEvaluationParameters& parameters) { + evaluated = unevaluated.evaluate(parameters); + + if (unevaluated.get().isUndefined()) { + evaluated.get() = evaluated.get(); + } + + passes = RenderPass::None; + + if (evaluated.get()) { + passes |= RenderPass::Translucent; + } + + if (!unevaluated.get().isUndefined() + || evaluated.get().constantOr(Color()).a < 1.0f + || evaluated.get().constantOr(0) < 1.0f) { + passes |= RenderPass::Translucent; + } else { + passes |= RenderPass::Opaque; + } + + return unevaluated.hasTransition(); +} + + +bool RenderFillLayer::queryIntersectsFeature( + const GeometryCoordinates& queryGeometry, + const GeometryTileFeature& feature, + const float, + const float bearing, + const float pixelsToTileUnits) const { + + auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry( + queryGeometry, + evaluated.get(), + evaluated.get(), + bearing, + pixelsToTileUnits); + + return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries()); +} + + +} diff --git a/src/mbgl/renderer/render_fill_layer.hpp b/src/mbgl/renderer/render_fill_layer.hpp new file mode 100644 index 0000000000..25b969d4c3 --- /dev/null +++ b/src/mbgl/renderer/render_fill_layer.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderFillLayer: public RenderLayer { +public: + + RenderFillLayer(const style::FillLayer::Impl&); + ~RenderFillLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + bool queryIntersectsFeature( + const GeometryCoordinates&, + const GeometryTileFeature&, + const float, + const float, + const float) const override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::FillPaintProperties::Unevaluated unevaluated; + style::FillPaintProperties::Evaluated evaluated; + + const style::FillLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Fill; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_item.hpp b/src/mbgl/renderer/render_item.hpp index b4b1f4aec2..575287d9c6 100644 --- a/src/mbgl/renderer/render_item.hpp +++ b/src/mbgl/renderer/render_item.hpp @@ -7,17 +7,17 @@ namespace mbgl { +class RenderLayer; class RenderTile; class Bucket; namespace style { -class Layer; class Source; } // namespace style class RenderItem { public: - RenderItem(const style::Layer& layer_, + RenderItem(const RenderLayer& layer_, const RenderTile* tile_ = nullptr, Bucket* bucket_ = nullptr) : tile(tile_), bucket(bucket_), layer(layer_) { @@ -25,7 +25,7 @@ public: const RenderTile* const tile; Bucket* const bucket; - const style::Layer& layer; + const RenderLayer& layer; }; class RenderData { diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp new file mode 100644 index 0000000000..6699f39144 --- /dev/null +++ b/src/mbgl/renderer/render_layer.cpp @@ -0,0 +1,25 @@ +#include +#include + +namespace mbgl { + +RenderLayer::RenderLayer(style::LayerType type_, const style::Layer::Impl& baseImpl_) + : type(type_), baseImpl(baseImpl_) { +} + +const std::string& RenderLayer::getID() const { + return baseImpl.id; +} + +bool RenderLayer::hasRenderPass(RenderPass pass) const { + return bool(passes & pass); +} + +bool RenderLayer::needsRendering(float zoom) const { + return passes != RenderPass::None + && baseImpl.visibility != style::VisibilityType::None + && baseImpl.minZoom <= zoom + && baseImpl.maxZoom >= zoom; +} + +} \ No newline at end of file diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp new file mode 100644 index 0000000000..af5345d5e3 --- /dev/null +++ b/src/mbgl/renderer/render_layer.hpp @@ -0,0 +1,87 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include + +namespace mbgl { + +class Bucket; +class BucketParameters; + +namespace style { +class CascadeParameters; +class PropertyEvaluationParameters; +} // namespace style + +class RenderLayer { + +protected: + RenderLayer(style::LayerType, const style::Layer::Impl&); + + const style::LayerType type; + +public: + + virtual ~RenderLayer() = default; + + // Create an identical copy of this layer. + virtual std::unique_ptr clone() const = 0; + + // Partially evaluate paint properties based on a set of classes. + virtual void cascade(const style::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 style::PropertyEvaluationParameters&) = 0; + + // Check whether this layer is of the given subtype. + template + bool is() const; + + // Dynamically cast this layer to the given subtype. + template + T* as() { + return is() ? reinterpret_cast(this) : nullptr; + } + + template + const T* as() const { + return is() ? reinterpret_cast(this) : nullptr; + } + + const std::string& getID() const; + + // 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; + + // Check wether the given geometry intersects + // with the feature + virtual bool queryIntersectsFeature( + const GeometryCoordinates&, + const GeometryTileFeature&, + const float, + const float, + const float) const { return false; }; + + virtual std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const = 0; + + // Private implementation + const style::Layer::Impl& baseImpl; + + friend std::string layoutKey(const RenderLayer&); +protected: + + // 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 mbgl diff --git a/src/mbgl/renderer/render_line_layer.cpp b/src/mbgl/renderer/render_line_layer.cpp new file mode 100644 index 0000000000..551d40bef5 --- /dev/null +++ b/src/mbgl/renderer/render_line_layer.cpp @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +RenderLineLayer::RenderLineLayer(const style::LineLayer::Impl& _impl) + : RenderLayer(style::LayerType::Line, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderLineLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderLineLayer::createBucket(const BucketParameters& parameters, const std::vector& layers) const { + return std::make_unique(parameters, layers, impl->layout); +} + +void RenderLineLayer::cascade(const style::CascadeParameters& parameters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderLineLayer::evaluate(const style::PropertyEvaluationParameters& parameters) { + // for scaling dasharrays + auto dashArrayParams = parameters; + dashArrayParams.z = std::floor(dashArrayParams.z); + dashLineWidth = unevaluated.evaluate(dashArrayParams); + + evaluated = unevaluated.evaluate(parameters); + + passes = (evaluated.get().constantOr(1.0) > 0 + && evaluated.get().constantOr(Color::black()).a > 0 + && evaluated.get() > 0) + ? RenderPass::Translucent : RenderPass::None; + + return unevaluated.hasTransition(); +} +optional offsetLine(const GeometryCollection& rings, const double offset) { + if (offset == 0) return {}; + + GeometryCollection newRings; + Point 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 aToB = i == ring.begin() ? + zero : + util::perp(util::unit(convertPoint(p - *(i - 1)))); + Point bToC = i + 1 == ring.end() ? + zero : + util::perp(util::unit(convertPoint(*(i + 1) - p))); + Point extrude = util::unit(aToB + bToC); + + const double cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y; + extrude *= (1.0 / cosHalfAngle); + + newRing.push_back(convertPoint(extrude * offset) + p); + } + } + + return newRings; +} + +bool RenderLineLayer::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, + evaluated.get(), + evaluated.get(), + bearing, + pixelsToTileUnits); + + // Evaluate function + auto offset = evaluated.get() + .evaluate(feature, zoom, style::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); +} + +float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const { + float lineWidth = evaluated.get(); + float gapWidth = evaluated.get() + .evaluate(feature, zoom, style::LineGapWidth::defaultValue()); + if (gapWidth) { + return gapWidth + 2 * lineWidth; + } else { + return lineWidth; + } +} + + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_line_layer.hpp b/src/mbgl/renderer/render_line_layer.hpp new file mode 100644 index 0000000000..0bde6f9a86 --- /dev/null +++ b/src/mbgl/renderer/render_line_layer.hpp @@ -0,0 +1,48 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderLineLayer: public RenderLayer { +public: + + RenderLineLayer(const style::LineLayer::Impl&); + ~RenderLineLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + bool queryIntersectsFeature( + const GeometryCoordinates&, + const GeometryTileFeature&, + const float, + const float, + const float) const override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::LinePaintProperties::Unevaluated unevaluated; + style::LinePaintProperties::Evaluated evaluated; + + const style::LineLayer::Impl* const impl; + + // Special case + float dashLineWidth = 1; + +private: + float getLineWidth(const GeometryTileFeature&, const float) const; + +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Line; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_raster_layer.cpp b/src/mbgl/renderer/render_raster_layer.cpp new file mode 100644 index 0000000000..f877a02398 --- /dev/null +++ b/src/mbgl/renderer/render_raster_layer.cpp @@ -0,0 +1,33 @@ +#include +#include +#include + +namespace mbgl { + +RenderRasterLayer::RenderRasterLayer(const style::RasterLayer::Impl& _impl) + : RenderLayer(style::LayerType::Raster, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderRasterLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderRasterLayer::createBucket(const BucketParameters&, const std::vector&) const { + assert(false); + return nullptr; +} + +void RenderRasterLayer::cascade(const style::CascadeParameters& parameters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderRasterLayer::evaluate(const style::PropertyEvaluationParameters& parameters) { + evaluated = unevaluated.evaluate(parameters); + + passes = evaluated.get() > 0 ? RenderPass::Translucent : RenderPass::None; + + return unevaluated.hasTransition(); +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_raster_layer.hpp b/src/mbgl/renderer/render_raster_layer.hpp new file mode 100644 index 0000000000..1fd0fe7c47 --- /dev/null +++ b/src/mbgl/renderer/render_raster_layer.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include +#include +#include + +namespace mbgl { + +class RenderRasterLayer: public RenderLayer { +public: + + RenderRasterLayer(const style::RasterLayer::Impl&); + ~RenderRasterLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + + // Paint properties + style::RasterPaintProperties::Unevaluated unevaluated; + style::RasterPaintProperties::Evaluated evaluated; + + const style::RasterLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Raster; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_symbol_layer.cpp b/src/mbgl/renderer/render_symbol_layer.cpp new file mode 100644 index 0000000000..90cc0a7615 --- /dev/null +++ b/src/mbgl/renderer/render_symbol_layer.cpp @@ -0,0 +1,113 @@ +#include +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +RenderSymbolLayer::RenderSymbolLayer(const style::SymbolLayer::Impl& _impl) + : RenderLayer(style::LayerType::Symbol, _impl), + impl(&_impl) { +} + +std::unique_ptr RenderSymbolLayer::clone() const { + return std::make_unique(*this); +} + +std::unique_ptr RenderSymbolLayer::createBucket(const BucketParameters&, const std::vector&) const { + assert(false); // Should be calling createLayout() instead. + return nullptr; +} + +std::unique_ptr RenderSymbolLayer::createLayout(const BucketParameters& parameters, + const std::vector& group, + const GeometryTileLayer& layer, + GlyphDependencies& glyphDependencies, + IconDependencyMap& iconDependencyMap) const { + return std::make_unique(parameters, + group, + layer, + iconDependencyMap[impl->spriteAtlas], + (uintptr_t) impl->spriteAtlas, + glyphDependencies); +} + +void RenderSymbolLayer::cascade(const style::CascadeParameters& parameters) { + unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated)); +} + +bool RenderSymbolLayer::evaluate(const style::PropertyEvaluationParameters& parameters) { + evaluated = unevaluated.evaluate(parameters); + + auto hasIconOpacity = evaluated.get().constantOr(Color::black()).a > 0 || + evaluated.get().constantOr(Color::black()).a > 0; + auto hasTextOpacity = evaluated.get().constantOr(Color::black()).a > 0 || + evaluated.get().constantOr(Color::black()).a > 0; + + passes = ((evaluated.get().constantOr(1) > 0 && hasIconOpacity && iconSize > 0) + || (evaluated.get().constantOr(1) > 0 && hasTextOpacity && textSize > 0)) + ? RenderPass::Translucent : RenderPass::None; + + return unevaluated.hasTransition(); +} + + +style::IconPaintProperties::Evaluated RenderSymbolLayer::iconPaintProperties() const { + return style::IconPaintProperties::Evaluated { + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get() + }; +} + +style::TextPaintProperties::Evaluated RenderSymbolLayer::textPaintProperties() const { + return style::TextPaintProperties::Evaluated { + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get(), + evaluated.get() + }; +} + + +style::SymbolPropertyValues RenderSymbolLayer::iconPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated& layout_) const { + return style::SymbolPropertyValues { + layout_.get(), // icon-pitch-alignment is not yet implemented; inherit the rotation alignment + layout_.get(), + layout_.get(), + evaluated.get(), + evaluated.get(), + iconSize, + 1.0f, + evaluated.get().constantOr(Color::black()).a > 0 && + evaluated.get().constantOr(1), + evaluated.get().constantOr(Color::black()).a > 0 + }; +} + +style::SymbolPropertyValues RenderSymbolLayer::textPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated& layout_) const { + return style::SymbolPropertyValues { + layout_.get(), + layout_.get(), + layout_.get(), + evaluated.get(), + evaluated.get(), + textSize, + 24.0f, + evaluated.get().constantOr(Color::black()).a > 0 && + evaluated.get().constantOr(1), + evaluated.get().constantOr(Color::black()).a > 0 + }; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/render_symbol_layer.hpp b/src/mbgl/renderer/render_symbol_layer.hpp new file mode 100644 index 0000000000..dbe7c4ea83 --- /dev/null +++ b/src/mbgl/renderer/render_symbol_layer.hpp @@ -0,0 +1,97 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace mbgl { + +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 layoutSize; + + // Paint + std::array translate; + TranslateAnchorType translateAnchor; + float paintSize; + + float sdfScale; // Constant (1.0 or 24.0) + + bool hasHalo; + bool hasFill; +}; + +} // namespace style + +class BucketParameters; +class SymbolLayout; +class GeometryTileLayer; + +class RenderSymbolLayer: public RenderLayer { +public: + RenderSymbolLayer(const style::SymbolLayer::Impl&); + ~RenderSymbolLayer() final = default; + + std::unique_ptr clone() const override; + + void cascade(const style::CascadeParameters&) override; + bool evaluate(const style::PropertyEvaluationParameters&) override; + + style::IconPaintProperties::Evaluated iconPaintProperties() const; + style::TextPaintProperties::Evaluated textPaintProperties() const; + + style::SymbolPropertyValues iconPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const; + style::SymbolPropertyValues textPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const; + + std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; + std::unique_ptr createLayout(const BucketParameters&, const std::vector&, + const GeometryTileLayer&, GlyphDependencies&, IconDependencyMap&) const; + + // Paint properties + style::SymbolPaintProperties::Unevaluated unevaluated; + style::SymbolPaintProperties::Evaluated evaluated; + + float iconSize = 1.0f; + float textSize = 16.0f; + + const style::SymbolLayer::Impl* const impl; +}; + +template <> +inline bool RenderLayer::is() const { + return type == style::LayerType::Symbol; +} + +} // namespace mbgl diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp index 77a9a75ef1..9b016c16f9 100644 --- a/src/mbgl/renderer/symbol_bucket.cpp +++ b/src/mbgl/renderer/symbol_bucket.cpp @@ -1,7 +1,7 @@ #include #include -#include -#include +#include +#include #include namespace mbgl { @@ -61,9 +61,9 @@ void SymbolBucket::upload(gl::Context& context) { void SymbolBucket::render(Painter& painter, PaintParameters& parameters, - const Layer& layer, + const RenderLayer& layer, const RenderTile& tile) { - painter.renderSymbol(parameters, *this, *layer.as(), tile); + painter.renderSymbol(parameters, *this, *layer.as(), tile); } bool SymbolBucket::hasData() const { diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index 659d7a3788..e00de03fd2 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -26,7 +26,7 @@ public: bool iconsNeedLinear); void upload(gl::Context&) override; - void render(Painter&, PaintParameters&, const style::Layer&, const RenderTile&) override; + void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override; bool hasData() const override; bool hasTextData() const; bool hasIconData() const; 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 - -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 -#include - -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 -#include -#include -#include -#include - -#include -#include - -#include - -namespace mbgl { -namespace style { - -std::string layoutKey(const Layer& layer) { - using namespace conversion; - - rapidjson::StringBuffer s; - rapidjson::Writer writer(s); - - writer.StartArray(); - writer.Uint(static_cast(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(layer.baseImpl->visibility)); - stringify(writer, layer.baseImpl->filter); - layer.baseImpl->stringifyLayout(writer); - writer.EndArray(); - - return s.GetString(); -} - -std::vector> groupByLayout(const std::vector>& layers) { - std::unordered_map> map; - for (auto& layer : layers) { - map[layoutKey(*layer)].push_back(layer.get()); - } - - std::vector> 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 -#include - -namespace mbgl { -namespace style { - -class Layer; - -std::vector> groupByLayout(const std::vector>&); - -} // 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 #include +#include namespace mbgl { namespace style { -Layer::Layer(Type type_, std::unique_ptr baseImpl_) +Layer::Layer(LayerType type_, std::unique_ptr 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::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 #include #include -#include #include -#include #include #include @@ -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&) 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 createBucket(const BucketParameters&, const std::vector&) 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 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()) + : Layer(LayerType::Background, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; } BackgroundLayer::BackgroundLayer(const Impl& other) - : Layer(Type::Background, std::make_unique(other)) + : Layer(LayerType::Background, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -27,7 +27,7 @@ std::unique_ptr BackgroundLayer::Impl::clone() const { std::unique_ptr BackgroundLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = BackgroundPaintProperties(); + result->impl->cascading = BackgroundPaintProperties::Cascading(); return std::move(result); } @@ -45,22 +45,22 @@ PropertyValue BackgroundLayer::getDefaultBackgroundColor() { } PropertyValue BackgroundLayer::getBackgroundColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void BackgroundLayer::setBackgroundColor(PropertyValue value, const optional& klass) { if (value == getBackgroundColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue BackgroundLayer::getDefaultBackgroundPattern() { @@ -68,22 +68,22 @@ PropertyValue BackgroundLayer::getDefaultBackgroundPattern() { } PropertyValue BackgroundLayer::getBackgroundPattern(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void BackgroundLayer::setBackgroundPattern(PropertyValue value, const optional& klass) { if (value == getBackgroundPattern(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundPatternTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundPatternTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue BackgroundLayer::getDefaultBackgroundOpacity() { @@ -91,22 +91,22 @@ PropertyValue BackgroundLayer::getDefaultBackgroundOpacity() { } PropertyValue BackgroundLayer::getBackgroundOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void BackgroundLayer::setBackgroundOpacity(PropertyValue value, const optional& klass) { if (value == getBackgroundOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void BackgroundLayer::setBackgroundOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions BackgroundLayer::getBackgroundOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include +#include 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() > 0 ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr BackgroundLayer::Impl::createBucket(const BucketParameters&, const std::vector&) const { - assert(false); - return nullptr; +std::unique_ptr BackgroundLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr createRenderLayer() const override; - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) 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()) + : Layer(LayerType::Circle, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } CircleLayer::CircleLayer(const Impl& other) - : Layer(Type::Circle, std::make_unique(other)) + : Layer(LayerType::Circle, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr CircleLayer::Impl::clone() const { std::unique_ptr CircleLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = CirclePaintProperties(); + result->impl->cascading = CirclePaintProperties::Cascading(); return std::move(result); } @@ -70,13 +70,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleRadius() { } DataDrivenPropertyValue CircleLayer::getCircleRadius(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleRadius(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleRadius(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -85,11 +85,11 @@ void CircleLayer::setCircleRadius(DataDrivenPropertyValue value, const op } void CircleLayer::setCircleRadiusTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleRadiusTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleColor() { @@ -97,13 +97,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleColor() { } DataDrivenPropertyValue CircleLayer::getCircleColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -112,11 +112,11 @@ void CircleLayer::setCircleColor(DataDrivenPropertyValue value, const opt } void CircleLayer::setCircleColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleBlur() { @@ -124,13 +124,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleBlur() { } DataDrivenPropertyValue CircleLayer::getCircleBlur(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleBlur(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleBlur(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -139,11 +139,11 @@ void CircleLayer::setCircleBlur(DataDrivenPropertyValue value, const opti } void CircleLayer::setCircleBlurTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleBlurTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleOpacity() { @@ -151,13 +151,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleOpacity() { } DataDrivenPropertyValue CircleLayer::getCircleOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -166,11 +166,11 @@ void CircleLayer::setCircleOpacity(DataDrivenPropertyValue value, const o } void CircleLayer::setCircleOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> CircleLayer::getDefaultCircleTranslate() { @@ -178,22 +178,22 @@ PropertyValue> CircleLayer::getDefaultCircleTranslate() { } PropertyValue> CircleLayer::getCircleTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleTranslate(PropertyValue> value, const optional& klass) { if (value == getCircleTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCircleTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue CircleLayer::getDefaultCircleTranslateAnchor() { @@ -201,22 +201,22 @@ PropertyValue CircleLayer::getDefaultCircleTranslateAnchor( } PropertyValue CircleLayer::getCircleTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getCircleTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCircleTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue CircleLayer::getDefaultCirclePitchScale() { @@ -224,22 +224,22 @@ PropertyValue CircleLayer::getDefaultCirclePitchScale() { } PropertyValue CircleLayer::getCirclePitchScale(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCirclePitchScale(PropertyValue value, const optional& klass) { if (value == getCirclePitchScale(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void CircleLayer::setCirclePitchScaleTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCirclePitchScaleTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeWidth() { @@ -247,13 +247,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeWidth() { } DataDrivenPropertyValue CircleLayer::getCircleStrokeWidth(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleStrokeWidth(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -262,11 +262,11 @@ void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue value, con } void CircleLayer::setCircleStrokeWidthTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeWidthTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeColor() { @@ -274,13 +274,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeColor() { } DataDrivenPropertyValue CircleLayer::getCircleStrokeColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleStrokeColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -289,11 +289,11 @@ void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue value, con } void CircleLayer::setCircleStrokeColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeOpacity() { @@ -301,13 +301,13 @@ DataDrivenPropertyValue CircleLayer::getDefaultCircleStrokeOpacity() { } DataDrivenPropertyValue CircleLayer::getCircleStrokeOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getCircleStrokeOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -316,11 +316,11 @@ void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue value, c } void CircleLayer::setCircleStrokeOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions CircleLayer::getCircleStrokeOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include -#include -#include -#include +#include 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().constantOr(1) > 0 || - paint.evaluated.get().constantOr(1) > 0) - && (paint.evaluated.get().constantOr(Color::black()).a > 0 || - paint.evaluated.get().constantOr(Color::black()).a > 0) - && (paint.evaluated.get().constantOr(1) > 0 || - paint.evaluated.get().constantOr(1) > 0)) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr CircleLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector& layers) const { - return std::make_unique(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(), paint.evaluated.get(), bearing, pixelsToTileUnits); - - // Evaluate function - auto circleRadius = paint.evaluated.get() - .evaluate(feature, zoom, CircleRadius::defaultValue()) - * pixelsToTileUnits; - - // Test intersection - return util::polygonIntersectsBufferedMultiPoint(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries(), circleRadius); +std::unique_ptr CircleLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr createRenderLayer() const override; - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) 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 #include +#include 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(layerID, init, render, deinit, context)) + : Layer(LayerType::Custom, std::make_unique(layerID, init, render, deinit, context)) , impl(static_cast(baseImpl.get())) { + Log::Info(Event::General, "New custom layer: %s", layerID.c_str()); } CustomLayer::CustomLayer(const Impl& other) - : Layer(Type::Custom, std::make_unique(other)) + : Layer(LayerType::Custom, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -22,7 +24,7 @@ CustomLayer::~CustomLayer() = default; template <> bool Layer::is() 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 -#include +#include #include - +#include namespace mbgl { namespace style { +std::unique_ptr CustomLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 CustomLayer::Impl::createBucket(const BucketParameters&, const std::vector&) 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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) final {} - bool evaluate(const PropertyEvaluationParameters&) final; - - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const final; + std::unique_ptr 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()) + : Layer(LayerType::FillExtrusion, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } FillExtrusionLayer::FillExtrusionLayer(const Impl& other) - : Layer(Type::FillExtrusion, std::make_unique(other)) + : Layer(LayerType::FillExtrusion, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr FillExtrusionLayer::Impl::clone() const { std::unique_ptr FillExtrusionLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = FillExtrusionPaintProperties(); + result->impl->cascading = FillExtrusionPaintProperties::Cascading(); return std::move(result); } @@ -70,22 +70,22 @@ PropertyValue FillExtrusionLayer::getDefaultFillExtrusionOpacity() { } PropertyValue FillExtrusionLayer::getFillExtrusionOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionOpacity(PropertyValue value, const optional& klass) { if (value == getFillExtrusionOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionColor() { @@ -93,13 +93,13 @@ DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionColor( } DataDrivenPropertyValue FillExtrusionLayer::getFillExtrusionColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillExtrusionColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -108,11 +108,11 @@ void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue va } void FillExtrusionLayer::setFillExtrusionColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> FillExtrusionLayer::getDefaultFillExtrusionTranslate() { @@ -120,22 +120,22 @@ PropertyValue> FillExtrusionLayer::getDefaultFillExtrusionT } PropertyValue> FillExtrusionLayer::getFillExtrusionTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionTranslate(PropertyValue> value, const optional& klass) { if (value == getFillExtrusionTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue FillExtrusionLayer::getDefaultFillExtrusionTranslateAnchor() { @@ -143,22 +143,22 @@ PropertyValue FillExtrusionLayer::getDefaultFillExtrusionTr } PropertyValue FillExtrusionLayer::getFillExtrusionTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getFillExtrusionTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue FillExtrusionLayer::getDefaultFillExtrusionPattern() { @@ -166,22 +166,22 @@ PropertyValue FillExtrusionLayer::getDefaultFillExtrusionPattern() } PropertyValue FillExtrusionLayer::getFillExtrusionPattern(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionPattern(PropertyValue value, const optional& klass) { if (value == getFillExtrusionPattern(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillExtrusionLayer::setFillExtrusionPatternTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionPatternTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionHeight() { @@ -189,13 +189,13 @@ DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionHeight } DataDrivenPropertyValue FillExtrusionLayer::getFillExtrusionHeight(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillExtrusionHeight(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -204,11 +204,11 @@ void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue v } void FillExtrusionLayer::setFillExtrusionHeightTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionHeightTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionBase() { @@ -216,13 +216,13 @@ DataDrivenPropertyValue FillExtrusionLayer::getDefaultFillExtrusionBase() } DataDrivenPropertyValue FillExtrusionLayer::getFillExtrusionBase(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillExtrusionBase(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -231,11 +231,11 @@ void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue val } void FillExtrusionLayer::setFillExtrusionBaseTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include +#include namespace mbgl { namespace style { -void FillExtrusionLayer::Impl::cascade(const CascadeParameters&) { -} - -bool FillExtrusionLayer::Impl::evaluate(const PropertyEvaluationParameters&) { - return false; -} - -std::unique_ptr FillExtrusionLayer::Impl::createBucket(const BucketParameters&, const std::vector&) const { - return nullptr; +std::unique_ptr FillExtrusionLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr createRenderLayer() const override; - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) 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()) + : Layer(LayerType::Fill, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } FillLayer::FillLayer(const Impl& other) - : Layer(Type::Fill, std::make_unique(other)) + : Layer(LayerType::Fill, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr FillLayer::Impl::clone() const { std::unique_ptr FillLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = FillPaintProperties(); + result->impl->cascading = FillPaintProperties::Cascading(); return std::move(result); } @@ -70,22 +70,22 @@ PropertyValue FillLayer::getDefaultFillAntialias() { } PropertyValue FillLayer::getFillAntialias(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillAntialias(PropertyValue value, const optional& klass) { if (value == getFillAntialias(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillAntialiasTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillAntialiasTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillLayer::getDefaultFillOpacity() { @@ -93,13 +93,13 @@ DataDrivenPropertyValue FillLayer::getDefaultFillOpacity() { } DataDrivenPropertyValue FillLayer::getFillOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -108,11 +108,11 @@ void FillLayer::setFillOpacity(DataDrivenPropertyValue value, const optio } void FillLayer::setFillOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillLayer::getDefaultFillColor() { @@ -120,13 +120,13 @@ DataDrivenPropertyValue FillLayer::getDefaultFillColor() { } DataDrivenPropertyValue FillLayer::getFillColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -135,11 +135,11 @@ void FillLayer::setFillColor(DataDrivenPropertyValue value, const optiona } void FillLayer::setFillColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue FillLayer::getDefaultFillOutlineColor() { @@ -147,13 +147,13 @@ DataDrivenPropertyValue FillLayer::getDefaultFillOutlineColor() { } DataDrivenPropertyValue FillLayer::getFillOutlineColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillOutlineColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getFillOutlineColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -162,11 +162,11 @@ void FillLayer::setFillOutlineColor(DataDrivenPropertyValue value, const } void FillLayer::setFillOutlineColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillOutlineColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> FillLayer::getDefaultFillTranslate() { @@ -174,22 +174,22 @@ PropertyValue> FillLayer::getDefaultFillTranslate() { } PropertyValue> FillLayer::getFillTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillTranslate(PropertyValue> value, const optional& klass) { if (value == getFillTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue FillLayer::getDefaultFillTranslateAnchor() { @@ -197,22 +197,22 @@ PropertyValue FillLayer::getDefaultFillTranslateAnchor() { } PropertyValue FillLayer::getFillTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getFillTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue FillLayer::getDefaultFillPattern() { @@ -220,22 +220,22 @@ PropertyValue FillLayer::getDefaultFillPattern() { } PropertyValue FillLayer::getFillPattern(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void FillLayer::setFillPattern(PropertyValue value, const optional& klass) { if (value == getFillPattern(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void FillLayer::setFillPatternTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions FillLayer::getFillPatternTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include -#include -#include -#include +#include 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().isUndefined()) { - paint.evaluated.get() = paint.evaluated.get(); - } - - passes = RenderPass::None; - - if (paint.evaluated.get()) { - passes |= RenderPass::Translucent; - } - - if (!paint.unevaluated.get().isUndefined() - || paint.evaluated.get().constantOr(Color()).a < 1.0f - || paint.evaluated.get().constantOr(0) < 1.0f) { - passes |= RenderPass::Translucent; - } else { - passes |= RenderPass::Opaque; - } - - return paint.hasTransition(); -} - -std::unique_ptr FillLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector& layers) const { - return std::make_unique(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(), paint.evaluated.get(), bearing, pixelsToTileUnits); - - return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries()); +std::unique_ptr FillLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr createRenderLayer() const override; - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) 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()) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique()) , impl(static_cast(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()) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique()) , impl(static_cast(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(other)) + : Layer(LayerType::<%- camelize(type) %>, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -41,7 +41,7 @@ std::unique_ptr <%- camelize(type) %>Layer::Impl::clone() const { std::unique_ptr <%- 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& 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& 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& 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& 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()) + : Layer(LayerType::Line, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } LineLayer::LineLayer(const Impl& other) - : Layer(Type::Line, std::make_unique(other)) + : Layer(LayerType::Line, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr LineLayer::Impl::clone() const { std::unique_ptr LineLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = LinePaintProperties(); + result->impl->cascading = LinePaintProperties::Cascading(); return std::move(result); } @@ -127,13 +127,13 @@ DataDrivenPropertyValue LineLayer::getDefaultLineOpacity() { } DataDrivenPropertyValue LineLayer::getLineOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getLineOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -142,11 +142,11 @@ void LineLayer::setLineOpacity(DataDrivenPropertyValue value, const optio } void LineLayer::setLineOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue LineLayer::getDefaultLineColor() { @@ -154,13 +154,13 @@ DataDrivenPropertyValue LineLayer::getDefaultLineColor() { } DataDrivenPropertyValue LineLayer::getLineColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getLineColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -169,11 +169,11 @@ void LineLayer::setLineColor(DataDrivenPropertyValue value, const optiona } void LineLayer::setLineColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> LineLayer::getDefaultLineTranslate() { @@ -181,22 +181,22 @@ PropertyValue> LineLayer::getDefaultLineTranslate() { } PropertyValue> LineLayer::getLineTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineTranslate(PropertyValue> value, const optional& klass) { if (value == getLineTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue LineLayer::getDefaultLineTranslateAnchor() { @@ -204,22 +204,22 @@ PropertyValue LineLayer::getDefaultLineTranslateAnchor() { } PropertyValue LineLayer::getLineTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getLineTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue LineLayer::getDefaultLineWidth() { @@ -227,22 +227,22 @@ PropertyValue LineLayer::getDefaultLineWidth() { } PropertyValue LineLayer::getLineWidth(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineWidth(PropertyValue value, const optional& klass) { if (value == getLineWidth(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineWidthTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineWidthTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue LineLayer::getDefaultLineGapWidth() { @@ -250,13 +250,13 @@ DataDrivenPropertyValue LineLayer::getDefaultLineGapWidth() { } DataDrivenPropertyValue LineLayer::getLineGapWidth(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineGapWidth(DataDrivenPropertyValue value, const optional& klass) { if (value == getLineGapWidth(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -265,11 +265,11 @@ void LineLayer::setLineGapWidth(DataDrivenPropertyValue value, const opti } void LineLayer::setLineGapWidthTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineGapWidthTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue LineLayer::getDefaultLineOffset() { @@ -277,13 +277,13 @@ DataDrivenPropertyValue LineLayer::getDefaultLineOffset() { } DataDrivenPropertyValue LineLayer::getLineOffset(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineOffset(DataDrivenPropertyValue value, const optional& klass) { if (value == getLineOffset(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -292,11 +292,11 @@ void LineLayer::setLineOffset(DataDrivenPropertyValue value, const option } void LineLayer::setLineOffsetTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineOffsetTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue LineLayer::getDefaultLineBlur() { @@ -304,13 +304,13 @@ DataDrivenPropertyValue LineLayer::getDefaultLineBlur() { } DataDrivenPropertyValue LineLayer::getLineBlur(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineBlur(DataDrivenPropertyValue value, const optional& klass) { if (value == getLineBlur(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -319,11 +319,11 @@ void LineLayer::setLineBlur(DataDrivenPropertyValue value, const optional } void LineLayer::setLineBlurTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineBlurTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> LineLayer::getDefaultLineDasharray() { @@ -331,22 +331,22 @@ PropertyValue> LineLayer::getDefaultLineDasharray() { } PropertyValue> LineLayer::getLineDasharray(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLineDasharray(PropertyValue> value, const optional& klass) { if (value == getLineDasharray(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLineDasharrayTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLineDasharrayTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue LineLayer::getDefaultLinePattern() { @@ -354,22 +354,22 @@ PropertyValue LineLayer::getDefaultLinePattern() { } PropertyValue LineLayer::getLinePattern(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void LineLayer::setLinePattern(PropertyValue value, const optional& klass) { if (value == getLinePattern(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void LineLayer::setLinePatternTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions LineLayer::getLinePatternTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include -#include -#include -#include -#include +#include 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(dashArrayParams); - - paint.evaluate(parameters); - - passes = (paint.evaluated.get().constantOr(1.0) > 0 - && paint.evaluated.get().constantOr(Color::black()).a > 0 - && paint.evaluated.get() > 0) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr LineLayer::Impl::createBucket(const BucketParameters& parameters, const std::vector& layers) const { - return std::make_unique(parameters, layers, layout); -} - -float LineLayer::Impl::getLineWidth(const GeometryTileFeature& feature, const float zoom) const { - float lineWidth = paint.evaluated.get(); - float gapWidth = paint.evaluated.get() - .evaluate(feature, zoom, LineGapWidth::defaultValue()); - if (gapWidth) { - return gapWidth + 2 * lineWidth; - } else { - return lineWidth; - } -} - -optional offsetLine(const GeometryCollection& rings, const double offset) { - if (offset == 0) return {}; - - GeometryCollection newRings; - Point 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 aToB = i == ring.begin() ? - zero : - util::perp(util::unit(convertPoint(p - *(i - 1)))); - Point bToC = i + 1 == ring.end() ? - zero : - util::perp(util::unit(convertPoint(*(i + 1) - p))); - Point extrude = util::unit(aToB + bToC); - - const double cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y; - extrude *= (1.0 / cosHalfAngle); - - newRing.push_back(convertPoint(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(), paint.evaluated.get(), bearing, pixelsToTileUnits); - - - // Evaluate function - auto offset = paint.evaluated.get().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 LineLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; - - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; - - bool queryIntersectsFeature( - const GeometryCoordinates&, - const GeometryTileFeature&, - const float, - const float, - const float) const override; + std::unique_ptr 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()) + : Layer(LayerType::Raster, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } RasterLayer::RasterLayer(const Impl& other) - : Layer(Type::Raster, std::make_unique(other)) + : Layer(LayerType::Raster, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr RasterLayer::Impl::clone() const { std::unique_ptr RasterLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = RasterPaintProperties(); + result->impl->cascading = RasterPaintProperties::Cascading(); return std::move(result); } @@ -52,22 +52,22 @@ PropertyValue RasterLayer::getDefaultRasterOpacity() { } PropertyValue RasterLayer::getRasterOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterOpacity(PropertyValue value, const optional& klass) { if (value == getRasterOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterHueRotate() { @@ -75,22 +75,22 @@ PropertyValue RasterLayer::getDefaultRasterHueRotate() { } PropertyValue RasterLayer::getRasterHueRotate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterHueRotate(PropertyValue value, const optional& klass) { if (value == getRasterHueRotate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterHueRotateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterBrightnessMin() { @@ -98,22 +98,22 @@ PropertyValue RasterLayer::getDefaultRasterBrightnessMin() { } PropertyValue RasterLayer::getRasterBrightnessMin(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterBrightnessMin(PropertyValue value, const optional& klass) { if (value == getRasterBrightnessMin(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterBrightnessMinTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterBrightnessMax() { @@ -121,22 +121,22 @@ PropertyValue RasterLayer::getDefaultRasterBrightnessMax() { } PropertyValue RasterLayer::getRasterBrightnessMax(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterBrightnessMax(PropertyValue value, const optional& klass) { if (value == getRasterBrightnessMax(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterBrightnessMaxTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterSaturation() { @@ -144,22 +144,22 @@ PropertyValue RasterLayer::getDefaultRasterSaturation() { } PropertyValue RasterLayer::getRasterSaturation(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterSaturation(PropertyValue value, const optional& klass) { if (value == getRasterSaturation(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterSaturationTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterContrast() { @@ -167,22 +167,22 @@ PropertyValue RasterLayer::getDefaultRasterContrast() { } PropertyValue RasterLayer::getRasterContrast(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterContrast(PropertyValue value, const optional& klass) { if (value == getRasterContrast(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterContrastTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue RasterLayer::getDefaultRasterFadeDuration() { @@ -190,22 +190,22 @@ PropertyValue RasterLayer::getDefaultRasterFadeDuration() { } PropertyValue RasterLayer::getRasterFadeDuration(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void RasterLayer::setRasterFadeDuration(PropertyValue value, const optional& klass) { if (value == getRasterFadeDuration(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions RasterLayer::getRasterFadeDurationTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include +#include 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() > 0 ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr RasterLayer::Impl::createBucket(const BucketParameters&, const std::vector&) const { - assert(false); - return nullptr; +std::unique_ptr RasterLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; + std::unique_ptr createRenderLayer() const override; - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) 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()) + : Layer(LayerType::Symbol, std::make_unique()) , impl(static_cast(baseImpl.get())) { impl->id = layerID; impl->source = sourceID; } SymbolLayer::SymbolLayer(const Impl& other) - : Layer(Type::Symbol, std::make_unique(other)) + : Layer(LayerType::Symbol, std::make_unique(other)) , impl(static_cast(baseImpl.get())) { } @@ -28,7 +28,7 @@ std::unique_ptr SymbolLayer::Impl::clone() const { std::unique_ptr SymbolLayer::Impl::cloneRef(const std::string& id_) const { auto result = std::make_unique(*this); result->impl->id = id_; - result->impl->paint = SymbolPaintProperties(); + result->impl->cascading = SymbolPaintProperties::Cascading(); return std::move(result); } @@ -547,13 +547,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultIconOpacity() { } DataDrivenPropertyValue SymbolLayer::getIconOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getIconOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -562,11 +562,11 @@ void SymbolLayer::setIconOpacity(DataDrivenPropertyValue value, const opt } void SymbolLayer::setIconOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultIconColor() { @@ -574,13 +574,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultIconColor() { } DataDrivenPropertyValue SymbolLayer::getIconColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getIconColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -589,11 +589,11 @@ void SymbolLayer::setIconColor(DataDrivenPropertyValue value, const optio } void SymbolLayer::setIconColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloColor() { @@ -601,13 +601,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloColor() { } DataDrivenPropertyValue SymbolLayer::getIconHaloColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getIconHaloColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -616,11 +616,11 @@ void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue value, const o } void SymbolLayer::setIconHaloColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloWidth() { @@ -628,13 +628,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloWidth() { } DataDrivenPropertyValue SymbolLayer::getIconHaloWidth(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue value, const optional& klass) { if (value == getIconHaloWidth(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -643,11 +643,11 @@ void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue value, const o } void SymbolLayer::setIconHaloWidthTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloWidthTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloBlur() { @@ -655,13 +655,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultIconHaloBlur() { } DataDrivenPropertyValue SymbolLayer::getIconHaloBlur(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue value, const optional& klass) { if (value == getIconHaloBlur(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -670,11 +670,11 @@ void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue value, const op } void SymbolLayer::setIconHaloBlurTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconHaloBlurTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> SymbolLayer::getDefaultIconTranslate() { @@ -682,22 +682,22 @@ PropertyValue> SymbolLayer::getDefaultIconTranslate() { } PropertyValue> SymbolLayer::getIconTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconTranslate(PropertyValue> value, const optional& klass) { if (value == getIconTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setIconTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue SymbolLayer::getDefaultIconTranslateAnchor() { @@ -705,22 +705,22 @@ PropertyValue SymbolLayer::getDefaultIconTranslateAnchor() } PropertyValue SymbolLayer::getIconTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setIconTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getIconTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setIconTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getIconTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultTextOpacity() { @@ -728,13 +728,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultTextOpacity() { } DataDrivenPropertyValue SymbolLayer::getTextOpacity(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextOpacity(DataDrivenPropertyValue value, const optional& klass) { if (value == getTextOpacity(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -743,11 +743,11 @@ void SymbolLayer::setTextOpacity(DataDrivenPropertyValue value, const opt } void SymbolLayer::setTextOpacityTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextOpacityTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultTextColor() { @@ -755,13 +755,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultTextColor() { } DataDrivenPropertyValue SymbolLayer::getTextColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getTextColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -770,11 +770,11 @@ void SymbolLayer::setTextColor(DataDrivenPropertyValue value, const optio } void SymbolLayer::setTextColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloColor() { @@ -782,13 +782,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloColor() { } DataDrivenPropertyValue SymbolLayer::getTextHaloColor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue value, const optional& klass) { if (value == getTextHaloColor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -797,11 +797,11 @@ void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue value, const o } void SymbolLayer::setTextHaloColorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloColorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloWidth() { @@ -809,13 +809,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloWidth() { } DataDrivenPropertyValue SymbolLayer::getTextHaloWidth(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue value, const optional& klass) { if (value == getTextHaloWidth(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -824,11 +824,11 @@ void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue value, const o } void SymbolLayer::setTextHaloWidthTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloWidthTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloBlur() { @@ -836,13 +836,13 @@ DataDrivenPropertyValue SymbolLayer::getDefaultTextHaloBlur() { } DataDrivenPropertyValue SymbolLayer::getTextHaloBlur(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue value, const optional& klass) { if (value == getTextHaloBlur(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); if (value.isDataDriven()) { impl->observer->onLayerDataDrivenPaintPropertyChanged(*this); } else { @@ -851,11 +851,11 @@ void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue value, const op } void SymbolLayer::setTextHaloBlurTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextHaloBlurTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue> SymbolLayer::getDefaultTextTranslate() { @@ -863,22 +863,22 @@ PropertyValue> SymbolLayer::getDefaultTextTranslate() { } PropertyValue> SymbolLayer::getTextTranslate(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextTranslate(PropertyValue> value, const optional& klass) { if (value == getTextTranslate(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setTextTranslateTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextTranslateTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().getTransition(klass); } PropertyValue SymbolLayer::getDefaultTextTranslateAnchor() { @@ -886,22 +886,22 @@ PropertyValue SymbolLayer::getDefaultTextTranslateAnchor() } PropertyValue SymbolLayer::getTextTranslateAnchor(const optional& klass) const { - return impl->paint.get(klass); + return impl->cascading.template get().get(klass); } void SymbolLayer::setTextTranslateAnchor(PropertyValue value, const optional& klass) { if (value == getTextTranslateAnchor(klass)) return; - impl->paint.set(value, klass); + impl->cascading.template get().set(value, klass); impl->observer->onLayerPaintPropertyChanged(*this); } void SymbolLayer::setTextTranslateAnchorTransition(const TransitionOptions& value, const optional& klass) { - impl->paint.setTransition(value, klass); + impl->cascading.template get().setTransition(value, klass); } TransitionOptions SymbolLayer::getTextTranslateAnchorTransition(const optional& klass) const { - return impl->paint.getTransition(klass); + return impl->cascading.template get().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 -#include -#include -#include +#include 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().constantOr(Color::black()).a > 0 || - paint.evaluated.get().constantOr(Color::black()).a > 0; - auto hasTextOpacity = paint.evaluated.get().constantOr(Color::black()).a > 0 || - paint.evaluated.get().constantOr(Color::black()).a > 0; - - passes = ((paint.evaluated.get().constantOr(1) > 0 && hasIconOpacity && iconSize > 0) - || (paint.evaluated.get().constantOr(1) > 0 && hasTextOpacity && textSize > 0)) - ? RenderPass::Translucent : RenderPass::None; - - return paint.hasTransition(); -} - -std::unique_ptr SymbolLayer::Impl::createBucket(const BucketParameters&, const std::vector&) const { - assert(false); // Should be calling createLayout() instead. - return nullptr; -} - -std::unique_ptr SymbolLayer::Impl::createLayout(const BucketParameters& parameters, - const std::vector& group, - const GeometryTileLayer& layer, - GlyphDependencies& glyphDependencies, - IconDependencyMap& iconDependencyMap) const { - return std::make_unique(parameters, - group, - layer, - iconDependencyMap[spriteAtlas], - (uintptr_t)spriteAtlas, - glyphDependencies); -} - -IconPaintProperties::Evaluated SymbolLayer::Impl::iconPaintProperties() const { - return IconPaintProperties::Evaluated { - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get() - }; -} - -TextPaintProperties::Evaluated SymbolLayer::Impl::textPaintProperties() const { - return TextPaintProperties::Evaluated { - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get(), - paint.evaluated.get() - }; -} - - -SymbolPropertyValues SymbolLayer::Impl::iconPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated& layout_) const { - return SymbolPropertyValues { - layout_.get(), // icon-pitch-alignment is not yet implemented; inherit the rotation alignment - layout_.get(), - layout_.get(), - paint.evaluated.get(), - paint.evaluated.get(), - iconSize, - 1.0f, - paint.evaluated.get().constantOr(Color::black()).a > 0 && - paint.evaluated.get().constantOr(1), - paint.evaluated.get().constantOr(Color::black()).a > 0 - }; -} - -SymbolPropertyValues SymbolLayer::Impl::textPropertyValues(const SymbolLayoutProperties::PossiblyEvaluated& layout_) const { - return SymbolPropertyValues { - layout_.get(), - layout_.get(), - layout_.get(), - paint.evaluated.get(), - paint.evaluated.get(), - textSize, - 24.0f, - paint.evaluated.get().constantOr(Color::black()).a > 0 && - paint.evaluated.get().constantOr(1), - paint.evaluated.get().constantOr(Color::black()).a > 0 - }; +std::unique_ptr SymbolLayer::Impl::createRenderLayer() const { + return std::make_unique(*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 -#include #include #include #include @@ -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 layoutSize; - - // Paint - std::array 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 cloneRef(const std::string& id) const override; void stringifyLayout(rapidjson::Writer&) const override; - void cascade(const CascadeParameters&) override; - bool evaluate(const PropertyEvaluationParameters&) override; - - std::unique_ptr createBucket(const BucketParameters&, const std::vector&) const override; - std::unique_ptr createLayout(const BucketParameters&, const std::vector&, - 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 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 { public: using Tuple::Tuple; - }; - class Cascading : public Tuple { - public: - using Tuple::Tuple; - }; - - template - auto get(const optional& klass) const { - return cascading.template get

().get(klass); - } - - template - void set(const typename P::ValueType& value, const optional& klass) { - cascading.template get

().set(value, klass); - } + bool hasTransition() const { + bool result = false; + util::ignore({ result |= this->template get().hasTransition()... }); + return result; + } - template - void setTransition(const TransitionOptions& value, const optional& klass) { - cascading.template get

().setTransition(value, klass); - } - - template - auto getTransition(const optional& klass) const { - return cascading.template get

().getTransition(klass); - } + template + auto evaluate(const PropertyEvaluationParameters& parameters) { + using Evaluator = typename P::EvaluatorType; - void cascade(const CascadeParameters& parameters) { - unevaluated = Unevaluated { - cascading.template get().cascade(parameters, - std::move(unevaluated.template get()))... - }; - } + return this->template get

().evaluate( + Evaluator(parameters, P::defaultValue()), + parameters.now + ); + } - template - auto evaluate(const PropertyEvaluationParameters& parameters) { - using Evaluator = typename P::EvaluatorType; - return unevaluated.template get

() - .evaluate(Evaluator(parameters, P::defaultValue()), parameters.now); - } + Evaluated evaluate(const PropertyEvaluationParameters& parameters) { + return Evaluated { + evaluate(parameters)... + }; + } - void evaluate(const PropertyEvaluationParameters& parameters) { - evaluated = Evaluated { - evaluate(parameters)... - }; - } + }; - bool hasTransition() const { - bool result = false; - util::ignore({ result |= unevaluated.template get().hasTransition()... }); - return result; - } + class Cascading : public Tuple { + public: + using Tuple::Tuple; - Cascading cascading; - Unevaluated unevaluated; - Evaluated evaluated; + Unevaluated cascade(const CascadeParameters& parameters, Unevaluated&& prior) const { + return Unevaluated { + this->template get().cascade( + parameters, + std::move(prior.template get()) + )... + }; + } + }; }; } // 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 #include #include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -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, optional 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 Style::removeLayer(const std::string& id) { @@ -244,9 +255,49 @@ std::unique_ptr Style::removeLayer(const std::string& id) { } layers.erase(it); + removeRenderLayer(id); return layer; } +std::vector Style::getRenderLayers() const { + std::vector result; + result.reserve(renderLayers.size()); + for (const auto& layer : renderLayers) { + result.push_back(layer.get()); + } + return result; +} + +std::vector Style::getRenderLayers() { + std::vector result; + result.reserve(renderLayers.size()); + for (auto& layer : renderLayers) { + result.push_back(layer.get()); + } + return result; +} + +std::vector>::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()) { + if (const RenderBackgroundLayer* background = layer->as()) { 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().from.empty()) { + const BackgroundPaintProperties::Evaluated& paint = background->evaluated; + if (layer.get() == renderLayers[0].get() && paint.get().from.empty()) { // This is a solid background. We can use glClear(). result.backgroundColor = paint.get() * paint.get(); } else { @@ -431,19 +482,19 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const continue; } - if (layer->is()) { + if (layer->is()) { 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(); + const bool symbolLayer = layer->is(); // 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 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 #include #include +#include #include #include #include @@ -31,6 +32,7 @@ class RenderData; class TransformState; class RenderedQueryOptions; class Scheduler; +class RenderLayer; namespace style { @@ -80,6 +82,11 @@ public: optional beforeLayerID = {}); std::unique_ptr removeLayer(const std::string& layerID); + // Should be moved to Impl eventually + std::vector getRenderLayers() const; + std::vector 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> sources; std::vector> layers; + std::vector> renderLayers; std::vector classes; TransitionOptions transitionOptions; @@ -127,6 +135,7 @@ private: double defaultPitch = 0; std::vector>::const_iterator findLayer(const std::string& layerID) const; + std::vector>::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; }; diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp index d3406e1a59..b47519d95c 100644 --- a/src/mbgl/tile/geometry_tile.cpp +++ b/src/mbgl/tile/geometry_tile.cpp @@ -6,7 +6,9 @@ #include #include #include -#include +#include +#include +#include #include #include #include @@ -159,9 +161,9 @@ void GeometryTile::getIcons(IconDependencyMap iconDependencyMap) { } } -Bucket* GeometryTile::getBucket(const Layer& layer) const { - const auto& buckets = layer.is() ? symbolBuckets : nonSymbolBuckets; - const auto it = buckets.find(layer.baseImpl->id); +Bucket* GeometryTile::getBucket(const RenderLayer& layer) const { + const auto& buckets = layer.is() ? symbolBuckets : nonSymbolBuckets; + const auto it = buckets.find(layer.baseImpl.id); if (it == buckets.end()) { return nullptr; } diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp index bfd036f3d5..3913fca812 100644 --- a/src/mbgl/tile/geometry_tile.hpp +++ b/src/mbgl/tile/geometry_tile.hpp @@ -18,10 +18,10 @@ namespace mbgl { class GeometryTileData; class FeatureIndex; class CollisionTile; +class RenderLayer; namespace style { class Style; -class Layer; class UpdateParameters; class SourceQueryOptions; } // namespace style @@ -46,7 +46,7 @@ public: void getGlyphs(GlyphDependencies); void getIcons(IconDependencyMap); - Bucket* getBucket(const style::Layer&) const override; + Bucket* getBucket(const RenderLayer&) const override; void queryRenderedFeatures( std::unordered_map>& result, diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp index d9b720d226..b745cccc89 100644 --- a/src/mbgl/tile/geometry_tile_worker.cpp +++ b/src/mbgl/tile/geometry_tile_worker.cpp @@ -4,12 +4,12 @@ #include #include #include -#include -#include +#include +#include #include #include -#include #include +#include #include #include #include @@ -252,6 +252,28 @@ void GeometryTileWorker::requestNewIcons(const IconDependencyMap &iconDependenci } } +static std::vector> toRenderLayers(const std::vector>& layers, float zoom) { + std::vector> renderLayers; + renderLayers.reserve(layers.size()); + for (auto& layer : layers) { + renderLayers.push_back(layer->baseImpl->createRenderLayer()); + + renderLayers.back()->cascade(style::CascadeParameters { + { ClassID::Default }, + Clock::time_point::max(), + TransitionOptions() + }); + + renderLayers.back()->evaluate(style::PropertyEvaluationParameters { + zoom, + Clock::time_point::max(), + ZoomHistory(), + Duration(0) + }); + } + return renderLayers; +} + void GeometryTileWorker::redoLayout() { if (!data || !layers) { return; @@ -272,7 +294,10 @@ void GeometryTileWorker::redoLayout() { GlyphDependencies glyphDependencies; IconDependencyMap iconDependencyMap; - std::vector> groups = groupByLayout(*layers); + // Create render layers and group by layout + std::vector> renderLayers = toRenderLayers(*layers, id.overscaledZ); + std::vector> groups = groupByLayout(renderLayers); + for (auto& group : groups) { if (obsolete) { return; @@ -282,9 +307,9 @@ void GeometryTileWorker::redoLayout() { continue; // Tile has no data. } - const Layer& leader = *group.at(0); + const RenderLayer& leader = *group.at(0); - auto geometryLayer = (*data)->getLayer(leader.baseImpl->sourceLayer); + auto geometryLayer = (*data)->getLayer(leader.baseImpl.sourceLayer); if (!geometryLayer) { continue; } @@ -296,13 +321,13 @@ void GeometryTileWorker::redoLayout() { featureIndex->setBucketLayerIDs(leader.getID(), layerIDs); - if (leader.is()) { + if (leader.is()) { symbolLayoutMap.emplace(leader.getID(), - leader.as()->impl->createLayout(parameters, group, *geometryLayer, glyphDependencies, iconDependencyMap)); + leader.as()->createLayout(parameters, group, *geometryLayer, glyphDependencies, iconDependencyMap)); } else { - const Filter& filter = leader.baseImpl->filter; - const std::string& sourceLayerID = leader.baseImpl->sourceLayer; - std::shared_ptr bucket = leader.baseImpl->createBucket(parameters, group); + const Filter& filter = leader.baseImpl.filter; + const std::string& sourceLayerID = leader.baseImpl.sourceLayer; + std::shared_ptr bucket = leader.createBucket(parameters, group); for (std::size_t i = 0; !obsolete && i < geometryLayer->featureCount(); i++) { std::unique_ptr feature = geometryLayer->getFeature(i); diff --git a/src/mbgl/tile/geometry_tile_worker.hpp b/src/mbgl/tile/geometry_tile_worker.hpp index 5ce4260fdf..ab3b9d7403 100644 --- a/src/mbgl/tile/geometry_tile_worker.hpp +++ b/src/mbgl/tile/geometry_tile_worker.hpp @@ -17,6 +17,7 @@ class GeometryTile; class GeometryTileData; class GlyphAtlas; class SymbolLayout; +class RenderLayer; namespace style { class Layer; diff --git a/src/mbgl/tile/raster_tile.cpp b/src/mbgl/tile/raster_tile.cpp index 1e3c772200..65907eb92a 100644 --- a/src/mbgl/tile/raster_tile.cpp +++ b/src/mbgl/tile/raster_tile.cpp @@ -55,7 +55,7 @@ void RasterTile::onError(std::exception_ptr err) { observer->onTileError(*this, err); } -Bucket* RasterTile::getBucket(const style::Layer&) const { +Bucket* RasterTile::getBucket(const RenderLayer&) const { return bucket.get(); } diff --git a/src/mbgl/tile/raster_tile.hpp b/src/mbgl/tile/raster_tile.hpp index cc0dbe71de..47f67a0842 100644 --- a/src/mbgl/tile/raster_tile.hpp +++ b/src/mbgl/tile/raster_tile.hpp @@ -29,7 +29,7 @@ public: optional expires_); void cancel() override; - Bucket* getBucket(const style::Layer&) const override; + Bucket* getBucket(const RenderLayer&) const override; void onParsed(std::unique_ptr result); void onError(std::exception_ptr); diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp index b3085071c2..6c2c78967f 100644 --- a/src/mbgl/tile/tile.hpp +++ b/src/mbgl/tile/tile.hpp @@ -22,9 +22,9 @@ class TransformState; class TileObserver; class PlacementConfig; class RenderedQueryOptions; +class RenderLayer; namespace style { -class Layer; class SourceQueryOptions; } // namespace style @@ -47,7 +47,7 @@ public: // Mark this tile as no longer needed and cancel any pending work. virtual void cancel() = 0; - virtual Bucket* getBucket(const style::Layer&) const = 0; + virtual Bucket* getBucket(const RenderLayer&) const = 0; virtual void setPlacementConfig(const PlacementConfig&) {} virtual void redoLayout() {} -- cgit v1.2.1