summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/mbgl/layermanager/circle_layer_factory.hpp2
-rw-r--r--include/mbgl/layermanager/fill_extrusion_layer_factory.hpp2
-rw-r--r--include/mbgl/layermanager/fill_layer_factory.hpp2
-rw-r--r--include/mbgl/layermanager/heatmap_layer_factory.hpp2
-rw-r--r--include/mbgl/layermanager/layer_factory.hpp7
-rw-r--r--include/mbgl/layermanager/layer_manager.hpp8
-rw-r--r--include/mbgl/layermanager/line_layer_factory.hpp2
-rw-r--r--include/mbgl/layermanager/symbol_layer_factory.hpp2
-rw-r--r--src/mbgl/layermanager/circle_layer_factory.cpp2
-rw-r--r--src/mbgl/layermanager/fill_extrusion_layer_factory.cpp6
-rw-r--r--src/mbgl/layermanager/fill_layer_factory.cpp6
-rw-r--r--src/mbgl/layermanager/heatmap_layer_factory.cpp2
-rw-r--r--src/mbgl/layermanager/layer_factory.cpp6
-rw-r--r--src/mbgl/layermanager/layer_manager.cpp5
-rw-r--r--src/mbgl/layermanager/line_layer_factory.cpp6
-rw-r--r--src/mbgl/layermanager/symbol_layer_factory.cpp2
-rw-r--r--src/mbgl/layout/pattern_layout.hpp68
-rw-r--r--src/mbgl/layout/symbol_layout.cpp18
-rw-r--r--src/mbgl/layout/symbol_layout.hpp3
-rw-r--r--src/mbgl/renderer/bucket.hpp3
-rw-r--r--src/mbgl/renderer/buckets/circle_bucket.cpp20
-rw-r--r--src/mbgl/renderer/buckets/circle_bucket.hpp2
-rw-r--r--src/mbgl/renderer/buckets/fill_bucket.cpp5
-rw-r--r--src/mbgl/renderer/buckets/fill_bucket.hpp2
-rw-r--r--src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp4
-rw-r--r--src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp2
-rw-r--r--src/mbgl/renderer/buckets/heatmap_bucket.cpp6
-rw-r--r--src/mbgl/renderer/buckets/heatmap_bucket.hpp2
-rw-r--r--src/mbgl/renderer/buckets/line_bucket.cpp31
-rw-r--r--src/mbgl/renderer/buckets/line_bucket.hpp7
-rw-r--r--src/mbgl/renderer/group_by_layout.cpp34
-rw-r--r--src/mbgl/renderer/group_by_layout.hpp6
-rw-r--r--src/mbgl/renderer/layers/render_background_layer.cpp33
-rw-r--r--src/mbgl/renderer/layers/render_background_layer.hpp14
-rw-r--r--src/mbgl/renderer/layers/render_circle_layer.cpp22
-rw-r--r--src/mbgl/renderer/layers/render_circle_layer.hpp12
-rw-r--r--src/mbgl/renderer/layers/render_custom_layer.cpp16
-rw-r--r--src/mbgl/renderer/layers/render_custom_layer.hpp16
-rw-r--r--src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp30
-rw-r--r--src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp24
-rw-r--r--src/mbgl/renderer/layers/render_fill_layer.cpp29
-rw-r--r--src/mbgl/renderer/layers/render_fill_layer.hpp20
-rw-r--r--src/mbgl/renderer/layers/render_heatmap_layer.cpp24
-rw-r--r--src/mbgl/renderer/layers/render_heatmap_layer.hpp16
-rw-r--r--src/mbgl/renderer/layers/render_hillshade_layer.cpp28
-rw-r--r--src/mbgl/renderer/layers/render_hillshade_layer.hpp8
-rw-r--r--src/mbgl/renderer/layers/render_line_layer.cpp29
-rw-r--r--src/mbgl/renderer/layers/render_line_layer.hpp22
-rw-r--r--src/mbgl/renderer/layers/render_raster_layer.cpp24
-rw-r--r--src/mbgl/renderer/layers/render_raster_layer.hpp10
-rw-r--r--src/mbgl/renderer/layers/render_symbol_layer.cpp25
-rw-r--r--src/mbgl/renderer/layers/render_symbol_layer.hpp30
-rw-r--r--src/mbgl/renderer/render_layer.cpp5
-rw-r--r--src/mbgl/renderer/render_layer.hpp8
-rw-r--r--src/mbgl/style/layers/custom_layer_impl.hpp7
-rw-r--r--src/mbgl/tile/geometry_tile_worker.cpp49
-rw-r--r--src/mbgl/tile/geometry_tile_worker.hpp3
-rw-r--r--test/renderer/group_by_layout.test.cpp60
-rw-r--r--test/test-files.json1
59 files changed, 383 insertions, 457 deletions
diff --git a/include/mbgl/layermanager/circle_layer_factory.hpp b/include/mbgl/layermanager/circle_layer_factory.hpp
index e9eb0f59cc..51135d3383 100644
--- a/include/mbgl/layermanager/circle_layer_factory.hpp
+++ b/include/mbgl/layermanager/circle_layer_factory.hpp
@@ -8,7 +8,7 @@ class CircleLayerFactory : public LayerFactory {
protected:
const style::LayerTypeInfo* getTypeInfo() const noexcept final;
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
- std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept final;
+ std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp b/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
index 3430d3da1c..fbaa5c1254 100644
--- a/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
+++ b/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
@@ -8,7 +8,7 @@ class FillExtrusionLayerFactory : public LayerFactory {
protected:
const style::LayerTypeInfo* getTypeInfo() const noexcept final;
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
- std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept final;
+ std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/include/mbgl/layermanager/fill_layer_factory.hpp b/include/mbgl/layermanager/fill_layer_factory.hpp
index 22762d1290..09afb0dc3a 100644
--- a/include/mbgl/layermanager/fill_layer_factory.hpp
+++ b/include/mbgl/layermanager/fill_layer_factory.hpp
@@ -8,7 +8,7 @@ class FillLayerFactory : public LayerFactory {
protected:
const style::LayerTypeInfo* getTypeInfo() const noexcept final;
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
- std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept final;
+ std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/include/mbgl/layermanager/heatmap_layer_factory.hpp b/include/mbgl/layermanager/heatmap_layer_factory.hpp
index 306af60938..2d0e1a5a02 100644
--- a/include/mbgl/layermanager/heatmap_layer_factory.hpp
+++ b/include/mbgl/layermanager/heatmap_layer_factory.hpp
@@ -8,7 +8,7 @@ class HeatmapLayerFactory : public LayerFactory {
protected:
const style::LayerTypeInfo* getTypeInfo() const noexcept final;
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
- std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept final;
+ std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/include/mbgl/layermanager/layer_factory.hpp b/include/mbgl/layermanager/layer_factory.hpp
index 037de1b647..f3cfef6bb6 100644
--- a/include/mbgl/layermanager/layer_factory.hpp
+++ b/include/mbgl/layermanager/layer_factory.hpp
@@ -6,6 +6,9 @@
namespace mbgl {
+namespace style {
+class LayerProperties;
+} // namespace style
class Bucket;
class BucketParameters;
class GeometryTileLayer;
@@ -28,9 +31,9 @@ public:
/// Returns a new RenderLayer instance.
virtual std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept = 0;
/// Returns a new Bucket instance on success call; returns `nullptr` otherwise.
- virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept;
+ virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
/// Returns a new Layout instance on success call; returns `nullptr` otherwise.
- virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept;
+ virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
protected:
optional<std::string> getSource(const style::conversion::Convertible& value) const noexcept;
diff --git a/include/mbgl/layermanager/layer_manager.hpp b/include/mbgl/layermanager/layer_manager.hpp
index de10b0207c..c6802dbb49 100644
--- a/include/mbgl/layermanager/layer_manager.hpp
+++ b/include/mbgl/layermanager/layer_manager.hpp
@@ -5,6 +5,9 @@
#include <vector>
namespace mbgl {
+namespace style {
+class LayerProperties;
+} // namespace style
class GeometryTileLayer;
class LayerFactory;
class RenderLayer;
@@ -37,9 +40,10 @@ public:
/// Returns a new RenderLayer instance on success call; returns `nullptr` otherwise.
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept;
/// Returns a new Bucket instance on success call; returns `nullptr` otherwise.
- std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept;
+ std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
/// Returns a new Layout instance on success call; returns `nullptr` otherwise.
- std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept;
+ std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>,
+ const std::vector<Immutable<style::LayerProperties>>&) noexcept;
/**
* @brief a build-time flag to enable/disable annotations in mapbox-gl-native core.
diff --git a/include/mbgl/layermanager/line_layer_factory.hpp b/include/mbgl/layermanager/line_layer_factory.hpp
index a7081228ee..803f550e57 100644
--- a/include/mbgl/layermanager/line_layer_factory.hpp
+++ b/include/mbgl/layermanager/line_layer_factory.hpp
@@ -10,7 +10,7 @@ protected:
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
std::unique_ptr<Layout> createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> tileLayer,
- const std::vector<const RenderLayer*>& group) noexcept final;
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/include/mbgl/layermanager/symbol_layer_factory.hpp b/include/mbgl/layermanager/symbol_layer_factory.hpp
index dac515c9dc..38f382e96c 100644
--- a/include/mbgl/layermanager/symbol_layer_factory.hpp
+++ b/include/mbgl/layermanager/symbol_layer_factory.hpp
@@ -10,7 +10,7 @@ protected:
std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
std::unique_ptr<Layout> createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> tileLayer,
- const std::vector<const RenderLayer*>& group) noexcept final;
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept final;
std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
};
diff --git a/src/mbgl/layermanager/circle_layer_factory.cpp b/src/mbgl/layermanager/circle_layer_factory.cpp
index 0ea56e5711..28c64fc400 100644
--- a/src/mbgl/layermanager/circle_layer_factory.cpp
+++ b/src/mbgl/layermanager/circle_layer_factory.cpp
@@ -24,7 +24,7 @@ std::unique_ptr<style::Layer> CircleLayerFactory::createLayer(const std::string&
return layer;
}
-std::unique_ptr<Bucket> CircleLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> CircleLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
return std::make_unique<CircleBucket>(parameters, layers);
}
diff --git a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
index b2558825ef..bc1647afa4 100644
--- a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
@@ -26,8 +26,10 @@ std::unique_ptr<style::Layer> FillExtrusionLayerFactory::createLayer(const std::
std::unique_ptr<Layout> FillExtrusionLayerFactory::createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> layer,
- const std::vector<const RenderLayer*>& group) noexcept {
- return std::make_unique<PatternLayout<FillExtrusionBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+ using namespace style;
+ using LayoutType = PatternLayout<FillExtrusionBucket, FillExtrusionLayerProperties, FillExtrusionPattern, FillExtrusionPaintProperties::PossiblyEvaluated>;
+ return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
}
std::unique_ptr<RenderLayer> FillExtrusionLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/fill_layer_factory.cpp b/src/mbgl/layermanager/fill_layer_factory.cpp
index 60a1818585..f9b59359c5 100644
--- a/src/mbgl/layermanager/fill_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_layer_factory.cpp
@@ -27,8 +27,10 @@ std::unique_ptr<style::Layer> FillLayerFactory::createLayer(const std::string& i
std::unique_ptr<Layout>
FillLayerFactory::createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> layer,
- const std::vector<const RenderLayer*>& group) noexcept {
- return std::make_unique<PatternLayout<FillBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+ using namespace style;
+ using LayoutType = PatternLayout<FillBucket, FillLayerProperties, FillPattern, FillPaintProperties::PossiblyEvaluated>;
+ return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
}
std::unique_ptr<RenderLayer> FillLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/heatmap_layer_factory.cpp b/src/mbgl/layermanager/heatmap_layer_factory.cpp
index 5d6a595b46..1cd5d18f79 100644
--- a/src/mbgl/layermanager/heatmap_layer_factory.cpp
+++ b/src/mbgl/layermanager/heatmap_layer_factory.cpp
@@ -24,7 +24,7 @@ std::unique_ptr<style::Layer> HeatmapLayerFactory::createLayer(const std::string
return layer;
}
-std::unique_ptr<Bucket> HeatmapLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> HeatmapLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
return std::make_unique<HeatmapBucket>(parameters, layers);
}
diff --git a/src/mbgl/layermanager/layer_factory.cpp b/src/mbgl/layermanager/layer_factory.cpp
index ceeb304f44..f4967b0e5d 100644
--- a/src/mbgl/layermanager/layer_factory.cpp
+++ b/src/mbgl/layermanager/layer_factory.cpp
@@ -25,12 +25,14 @@ optional<std::string> LayerFactory::getSource(const style::conversion::Convertib
return source;
}
-std::unique_ptr<Bucket> LayerFactory::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept {
+std::unique_ptr<Bucket> LayerFactory::createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept {
assert(false);
return nullptr;
}
-std::unique_ptr<Layout> LayerFactory::createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept {
+std::unique_ptr<Layout> LayerFactory::createLayout(const LayoutParameters&,
+ std::unique_ptr<GeometryTileLayer>,
+ const std::vector<Immutable<style::LayerProperties>>&) noexcept {
assert(false);
return nullptr;
}
diff --git a/src/mbgl/layermanager/layer_manager.cpp b/src/mbgl/layermanager/layer_manager.cpp
index e6195caeba..1e2074cd70 100644
--- a/src/mbgl/layermanager/layer_manager.cpp
+++ b/src/mbgl/layermanager/layer_manager.cpp
@@ -25,7 +25,8 @@ std::unique_ptr<style::Layer> LayerManager::createLayer(
return nullptr;
}
-std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& parameters,
+ const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
assert(!layers.empty());
assert(parameters.layerType->layout == style::LayerTypeInfo::Layout::NotRequired);
LayerFactory* factory = getFactory(parameters.layerType);
@@ -35,7 +36,7 @@ std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& param
std::unique_ptr<Layout> LayerManager::createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> tileLayer,
- const std::vector<const RenderLayer*>& layers) noexcept {
+ const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
assert(!layers.empty());
assert(parameters.bucketParameters.layerType->layout == style::LayerTypeInfo::Layout::Required);
LayerFactory* factory = getFactory(parameters.bucketParameters.layerType);
diff --git a/src/mbgl/layermanager/line_layer_factory.cpp b/src/mbgl/layermanager/line_layer_factory.cpp
index 8bf756e159..212fb45665 100644
--- a/src/mbgl/layermanager/line_layer_factory.cpp
+++ b/src/mbgl/layermanager/line_layer_factory.cpp
@@ -26,8 +26,10 @@ std::unique_ptr<style::Layer> LineLayerFactory::createLayer(const std::string& i
std::unique_ptr<Layout> LineLayerFactory::createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> layer,
- const std::vector<const RenderLayer*>& group) noexcept {
- return std::make_unique<PatternLayout<LineBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+ using namespace style;
+ using LayoutType = PatternLayout<LineBucket, LineLayerProperties, LinePattern, LinePaintProperties::PossiblyEvaluated, LineLayoutProperties::PossiblyEvaluated>;
+ return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
}
std::unique_ptr<RenderLayer> LineLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/symbol_layer_factory.cpp b/src/mbgl/layermanager/symbol_layer_factory.cpp
index d992741551..f5a4640db7 100644
--- a/src/mbgl/layermanager/symbol_layer_factory.cpp
+++ b/src/mbgl/layermanager/symbol_layer_factory.cpp
@@ -26,7 +26,7 @@ std::unique_ptr<style::Layer> SymbolLayerFactory::createLayer(const std::string&
std::unique_ptr<Layout> SymbolLayerFactory::createLayout(const LayoutParameters& parameters,
std::unique_ptr<GeometryTileLayer> tileLayer,
- const std::vector<const RenderLayer*>& group) noexcept {
+ const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
return std::make_unique<SymbolLayout>(parameters.bucketParameters,
group,
std::move(tileLayer),
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index 8dabfab919..fe2e9c5950 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -3,6 +3,7 @@
#include <mbgl/renderer/bucket_parameters.hpp>
#include <mbgl/geometry/feature_index.hpp>
#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/style/layer_properties.hpp>
namespace mbgl {
@@ -22,31 +23,32 @@ public:
PatternLayerMap patterns;
};
-template <class B>
+template <class BucketType,
+ class LayerPropertiesType,
+ class PatternPropertyType,
+ class PossiblyEvaluatedPaintPropertiesType,
+ class PossiblyEvaluatedLayoutPropertiesType = typename style::Properties<>::PossiblyEvaluated>
class PatternLayout : public Layout {
public:
PatternLayout(const BucketParameters& parameters,
- const std::vector<const RenderLayer*>& layers,
+ const std::vector<Immutable<style::LayerProperties>>& group,
std::unique_ptr<GeometryTileLayer> sourceLayer_,
ImageDependencies& patternDependencies)
- : Layout(),
- bucketLeaderID(layers.at(0)->getID()),
- sourceLayer(std::move(sourceLayer_)),
+ : sourceLayer(std::move(sourceLayer_)),
zoom(parameters.tileID.overscaledZ),
overscaling(parameters.tileID.overscaleFactor()),
hasPattern(false) {
-
- using PatternLayer = typename B::RenderLayerType;
- const auto renderLayer = static_cast<const PatternLayer*>(layers.at(0));
- const typename PatternLayer::StyleLayerImpl& leader = renderLayer->impl();
- layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom));
- sourceLayerID = leader.sourceLayer;
- groupID = renderLayer->getID();
-
- for (const auto& layer : layers) {
- const typename B::PossiblyEvaluatedPaintProperties evaluatedProps = static_cast<const PatternLayer*>(layer)->evaluated;
- const auto patternProperty = evaluatedProps.template get<typename PatternLayer::PatternProperty>();
- const auto constantPattern = patternProperty.constantOr({ "", "" });
+ assert(!group.empty());
+ auto leaderLayerProperties = staticImmutableCast<LayerPropertiesType>(group.front());
+ layout = leaderLayerProperties->layerImpl().layout.evaluate(PropertyEvaluationParameters(zoom));
+ sourceLayerID = leaderLayerProperties->layerImpl().sourceLayer;
+ bucketLeaderID = leaderLayerProperties->layerImpl().id;
+
+ for (const auto& layerProperties : group) {
+ const std::string& layerId = layerProperties->baseImpl->id;
+ const auto evaluatedProps = static_cast<const LayerPropertiesType&>(*layerProperties).evaluated;
+ const auto patternProperty = evaluatedProps.template get<PatternPropertyType>();
+ const auto constantPattern = patternProperty.constantOr(Faded<std::basic_string<char> >{ "", ""});
// determine if layer group has any layers that use *-pattern property and add
// constant pattern dependencies.
if (!patternProperty.isConstant()) {
@@ -56,33 +58,34 @@ public:
patternDependencies.emplace(constantPattern.to, ImageType::Pattern);
patternDependencies.emplace(constantPattern.from, ImageType::Pattern);
}
- layerPaintProperties.emplace(layer->getID(), std::move(evaluatedProps));
+ layerPaintProperties.emplace(layerId, std::move(evaluatedProps));
}
const size_t featureCount = sourceLayer->featureCount();
for (size_t i = 0; i < featureCount; ++i) {
auto feature = sourceLayer->getFeature(i);
- if (!leader.filter(style::expression::EvaluationContext { this->zoom, feature.get() }))
+ if (!leaderLayerProperties->layerImpl().filter(style::expression::EvaluationContext { this->zoom, feature.get() }))
continue;
PatternLayerMap patternDependencyMap;
if (hasPattern) {
- for (const auto& layer : layers) {
- const auto it = layerPaintProperties.find(layer->getID());
+ for (const auto& layerProperties : group) {
+ const std::string& layerId = layerProperties->baseImpl->id;
+ const auto it = layerPaintProperties.find(layerId);
if (it != layerPaintProperties.end()) {
const auto paint = it->second;
- const auto patternProperty = paint.template get<typename PatternLayer::PatternProperty>();
+ const auto patternProperty = paint.template get<PatternPropertyType>();
if (!patternProperty.isConstant()) {
// For layers with non-data-constant pattern properties, evaluate their expression and add
// the patterns to the dependency vector
- const auto min = patternProperty.evaluate(*feature, zoom - 1, PatternLayer::PatternProperty::defaultValue());
- const auto mid = patternProperty.evaluate(*feature, zoom, PatternLayer::PatternProperty::defaultValue());
- const auto max = patternProperty.evaluate(*feature, zoom + 1, PatternLayer::PatternProperty::defaultValue());
+ const auto min = patternProperty.evaluate(*feature, zoom - 1, PatternPropertyType::defaultValue());
+ const auto mid = patternProperty.evaluate(*feature, zoom, PatternPropertyType::defaultValue());
+ const auto max = patternProperty.evaluate(*feature, zoom + 1, PatternPropertyType::defaultValue());
patternDependencies.emplace(min.to, ImageType::Pattern);
patternDependencies.emplace(mid.to, ImageType::Pattern);
patternDependencies.emplace(max.to, ImageType::Pattern);
- patternDependencyMap.emplace(layer->getID(), PatternDependency {min.to, mid.to, max.to});
+ patternDependencyMap.emplace(layerId, PatternDependency {min.to, mid.to, max.to});
}
}
@@ -99,15 +102,15 @@ public:
}
void createBucket(const ImagePositions& patternPositions, std::unique_ptr<FeatureIndex>& featureIndex, std::unordered_map<std::string, std::shared_ptr<Bucket>>& buckets, const bool, const bool) override {
- auto bucket = std::make_shared<B>(layout, layerPaintProperties, zoom, overscaling);
+ auto bucket = std::make_shared<BucketType>(layout, layerPaintProperties, zoom, overscaling);
for (auto & patternFeature : features) {
const auto i = patternFeature.i;
std::unique_ptr<GeometryTileFeature> feature = std::move(patternFeature.feature);
- PatternLayerMap patterns = patternFeature.patterns;
+ const PatternLayerMap& patterns = patternFeature.patterns;
GeometryCollection geometries = feature->getGeometries();
bucket->addFeature(*feature, geometries, patternPositions, patterns);
- featureIndex->insert(geometries, i, sourceLayerID, groupID);
+ featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID);
}
if (bucket->hasData()) {
for (const auto& pair : layerPaintProperties) {
@@ -116,19 +119,18 @@ public:
}
};
- std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
- const std::string bucketLeaderID;
+ std::map<std::string, PossiblyEvaluatedPaintPropertiesType> layerPaintProperties;
+ std::string bucketLeaderID;
private:
const std::unique_ptr<GeometryTileLayer> sourceLayer;
std::vector<PatternFeature> features;
- typename B::PossiblyEvaluatedLayoutProperties layout;
+ PossiblyEvaluatedLayoutPropertiesType layout;
const float zoom;
const uint32_t overscaling;
std::string sourceLayerID;
- std::string groupID;
bool hasPattern;
};
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 03cfe506ec..0eb98f7569 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -40,16 +40,18 @@ expression::Value sectionOptionsToValue(const SectionOptions& options) {
}
return result;
}
-} // namespace
+inline const SymbolLayerProperties& toSymbolLayerProperties(const Immutable<LayerProperties>& layer) {
+ return static_cast<const SymbolLayerProperties&>(*layer);
+}
+} // namespace
SymbolLayout::SymbolLayout(const BucketParameters& parameters,
- const std::vector<const RenderLayer*>& layers,
+ const std::vector<Immutable<style::LayerProperties>>& layers,
std::unique_ptr<GeometryTileLayer> sourceLayer_,
ImageDependencies& imageDependencies,
GlyphDependencies& glyphDependencies)
- : Layout(),
- bucketLeaderID(layers.at(0)->getID()),
+ : bucketLeaderID(layers.front()->baseImpl->id),
sourceLayer(std::move(sourceLayer_)),
overscaling(parameters.tileID.overscaleFactor()),
zoom(parameters.tileID.overscaledZ),
@@ -57,11 +59,11 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
pixelRatio(parameters.pixelRatio),
tileSize(util::tileSize * overscaling),
tilePixelRatio(float(util::EXTENT) / tileSize),
- textSize(toRenderSymbolLayer(layers.at(0))->impl().layout.get<TextSize>()),
- iconSize(toRenderSymbolLayer(layers.at(0))->impl().layout.get<IconSize>())
+ textSize(toSymbolLayerProperties(layers.at(0)).layerImpl().layout.get<TextSize>()),
+ iconSize(toSymbolLayerProperties(layers.at(0)).layerImpl().layout.get<IconSize>())
{
- const SymbolLayer::Impl& leader = toRenderSymbolLayer(layers.at(0))->impl();
+ const SymbolLayer::Impl& leader = toSymbolLayerProperties(layers.at(0)).layerImpl();
layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom));
@@ -104,7 +106,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
layout.get<TextIgnorePlacement>() || layout.get<IconIgnorePlacement>());
for (const auto& layer : layers) {
- layerPaintProperties.emplace(layer->getID(), toRenderSymbolLayer(layer)->evaluated);
+ layerPaintProperties.emplace(layer->baseImpl->id, toSymbolLayerProperties(layer).evaluated);
}
// Determine glyph dependencies
diff --git a/src/mbgl/layout/symbol_layout.hpp b/src/mbgl/layout/symbol_layout.hpp
index 9b8b0adfcc..9fc48d904c 100644
--- a/src/mbgl/layout/symbol_layout.hpp
+++ b/src/mbgl/layout/symbol_layout.hpp
@@ -16,7 +16,6 @@ namespace mbgl {
class BucketParameters;
class Anchor;
-class RenderLayer;
class PlacedSymbol;
namespace style {
@@ -26,7 +25,7 @@ class Filter;
class SymbolLayout final : public Layout {
public:
SymbolLayout(const BucketParameters&,
- const std::vector<const RenderLayer*>&,
+ const std::vector<Immutable<style::LayerProperties>>&,
std::unique_ptr<GeometryTileLayer>,
ImageDependencies&,
GlyphDependencies&);
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index 1d775ede04..e345f0b5ec 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -31,9 +31,6 @@ public:
const ImagePositions&,
const PatternLayerMap&) {};
- virtual void populateFeatureBuffers(const ImagePositions&) {};
- virtual void addPatternDependencies(const std::vector<const RenderLayer*>&, ImageDependencies&) {};
-
// As long as this bucket has a Prepare render pass, this function is getting called. Typically,
// this only happens once when the bucket is being rendered for the first time.
virtual void upload(gfx::Context&) = 0;
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index 54ed374069..376f4e682f 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -10,14 +10,14 @@ namespace mbgl {
using namespace style;
-CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& 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->baseImpl->id),
std::forward_as_tuple(
- toRenderCircleLayer(layer)->evaluated,
+ getEvaluated<CircleLayerProperties>(layer),
parameters.tileID.overscaledZ));
}
}
@@ -99,20 +99,20 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
}
template <class Property>
-static float get(const RenderCircleLayer& layer, const std::map<std::string, CircleProgram::Binders>& paintPropertyBinders) {
- auto it = paintPropertyBinders.find(layer.getID());
+static float get(const CirclePaintProperties::PossiblyEvaluated& evaluated, const std::string& id, const std::map<std::string, CircleProgram::Binders>& paintPropertyBinders) {
+ auto it = paintPropertyBinders.find(id);
if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
- return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+ return evaluated.get<Property>().constantOr(Property::defaultValue());
} else {
return *it->second.statistics<Property>().max();
}
}
float CircleBucket::getQueryRadius(const RenderLayer& layer) const {
- const RenderCircleLayer* circleLayer = toRenderCircleLayer(&layer);
- float radius = get<CircleRadius>(*circleLayer, paintPropertyBinders);
- float stroke = get<CircleStrokeWidth>(*circleLayer, paintPropertyBinders);
- auto translate = circleLayer->evaluated.get<CircleTranslate>();
+ const auto& evaluated = getEvaluated<CircleLayerProperties>(layer.evaluatedProperties);
+ float radius = get<CircleRadius>(evaluated, layer.getID(), paintPropertyBinders);
+ float stroke = get<CircleStrokeWidth>(evaluated, layer.getID(), paintPropertyBinders);
+ auto translate = evaluated.get<CircleTranslate>();
return radius + stroke + util::length(translate[0], translate[1]);
}
diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp
index e9aceed2b1..58f76327ab 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.hpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.hpp
@@ -15,7 +15,7 @@ class BucketParameters;
class CircleBucket final : public Bucket {
public:
- CircleBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+ CircleBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
~CircleBucket() override;
void addFeature(const GeometryTileFeature&,
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index 927cb4a307..2dffc555e2 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -141,10 +141,9 @@ bool FillBucket::supportsLayer(const style::Layer::Impl& impl) const {
return style::FillLayer::Impl::staticTypeInfo() == impl.getTypeInfo();
}
-
float FillBucket::getQueryRadius(const RenderLayer& layer) const {
- const RenderFillLayer* fillLayer = toRenderFillLayer(&layer);
- const std::array<float, 2>& translate = fillLayer->evaluated.get<FillTranslate>();
+ const auto& evaluated = getEvaluated<FillLayerProperties>(layer.evaluatedProperties);
+ const std::array<float, 2>& translate = evaluated.get<FillTranslate>();
return util::length(translate[0], translate[1]);
}
diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp
index e1869e08d2..5844625d2a 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.hpp
@@ -18,8 +18,6 @@ class RenderFillLayer;
class FillBucket final : public Bucket {
public:
~FillBucket() override;
- // These aliases are used by the PatternLayout template
- using RenderLayerType = RenderFillLayer;
using PossiblyEvaluatedPaintProperties = style::FillPaintProperties::PossiblyEvaluated;
using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index e640cf504d..61fc6a1444 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -185,8 +185,8 @@ bool FillExtrusionBucket::supportsLayer(const style::Layer::Impl& impl) const {
}
float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const {
- const RenderFillExtrusionLayer* fillExtrusionLayer = toRenderFillExtrusionLayer(&layer);
- const std::array<float, 2>& translate = fillExtrusionLayer->evaluated.get<FillExtrusionTranslate>();
+ const auto& evaluated = getEvaluated<FillExtrusionLayerProperties>(layer.evaluatedProperties);
+ const std::array<float, 2>& translate = evaluated.get<FillExtrusionTranslate>();
return util::length(translate[0], translate[1]);
}
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
index 81685e2c42..9dc2681bac 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
@@ -16,8 +16,6 @@ class RenderFillExtrusionLayer;
class FillExtrusionBucket final : public Bucket {
public:
~FillExtrusionBucket() override;
- // These aliases are used by the PatternLayout template
- using RenderLayerType = RenderFillExtrusionLayer;
using PossiblyEvaluatedPaintProperties = style::FillExtrusionPaintProperties::PossiblyEvaluated;
using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
index 04fd58ec55..111911a88c 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
@@ -10,14 +10,14 @@ namespace mbgl {
using namespace style;
-HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& 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->baseImpl->id),
std::forward_as_tuple(
- toRenderHeatmapLayer(layer)->evaluated,
+ getEvaluated<HeatmapLayerProperties>(layer),
parameters.tileID.overscaledZ));
}
}
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
index 62cb460e27..b11c1626cd 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
@@ -15,7 +15,7 @@ class BucketParameters;
class HeatmapBucket final : public Bucket {
public:
- HeatmapBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+ HeatmapBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
~HeatmapBucket() override;
void addFeature(const GeometryTileFeature&,
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 13f575ba38..9a5ed9e628 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -11,10 +11,10 @@ namespace mbgl {
using namespace style;
LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layout_,
- std::map<std::string, style::LinePaintProperties::PossiblyEvaluated> layerPaintProperties,
+ const std::map<std::string, style::LinePaintProperties::PossiblyEvaluated>& layerPaintProperties,
const float zoom_,
const uint32_t overscaling_)
- : layout(layout_),
+ : layout(std::move(layout_)),
zoom(zoom_),
overscaling(overscaling_) {
@@ -528,31 +528,26 @@ bool LineBucket::supportsLayer(const style::Layer::Impl& impl) const {
}
template <class Property>
-static float get(const RenderLineLayer& layer, const std::map<std::string, LineProgram::Binders>& paintPropertyBinders) {
- auto it = paintPropertyBinders.find(layer.getID());
+static float get(const LinePaintProperties::PossiblyEvaluated& evaluated, const std::string& id, const std::map<std::string, LineProgram::Binders>& paintPropertyBinders) {
+ auto it = paintPropertyBinders.find(id);
if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
- return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+ return evaluated.get<Property>().constantOr(Property::defaultValue());
} else {
return *it->second.statistics<Property>().max();
}
}
-float LineBucket::getLineWidth(const RenderLineLayer& layer) const {
- float lineWidth = get<LineWidth>(layer, paintPropertyBinders);
- float gapWidth = get<LineGapWidth>(layer, paintPropertyBinders);
-
+float LineBucket::getQueryRadius(const RenderLayer& layer) const {
+ const auto& evaluated = getEvaluated<LineLayerProperties>(layer.evaluatedProperties);
+ const std::array<float, 2>& translate = evaluated.get<LineTranslate>();
+ float offset = get<LineOffset>(evaluated, layer.getID(), paintPropertyBinders);
+ float lineWidth = get<LineWidth>(evaluated, layer.getID(), paintPropertyBinders);
+ float gapWidth = get<LineGapWidth>(evaluated, layer.getID(), paintPropertyBinders);
if (gapWidth) {
- return gapWidth + 2 * lineWidth;
- } else {
- return lineWidth;
+ lineWidth = gapWidth + 2 * lineWidth;
}
-}
-float LineBucket::getQueryRadius(const RenderLayer& layer) const {
- const RenderLineLayer* lineLayer = toRenderLineLayer(&layer);
- const std::array<float, 2>& translate = lineLayer->evaluated.get<LineTranslate>();
- float offset = get<LineOffset>(*lineLayer, paintPropertyBinders);
- return getLineWidth(*lineLayer) / 2.0 + std::abs(offset) + util::length(translate[0], translate[1]);
+ return lineWidth / 2.0f + std::abs(offset) + util::length(translate[0], translate[1]);
}
} // namespace mbgl
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 7ee8677e50..6717ee7446 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -17,14 +17,11 @@ class RenderLineLayer;
class LineBucket final : public Bucket {
public:
-
- // These aliases are used by the PatternLayout template
- using RenderLayerType = RenderLineLayer;
using PossiblyEvaluatedPaintProperties = style::LinePaintProperties::PossiblyEvaluated;
using PossiblyEvaluatedLayoutProperties = style::LineLayoutProperties::PossiblyEvaluated;
LineBucket(const PossiblyEvaluatedLayoutProperties layout,
- std::map<std::string, PossiblyEvaluatedPaintProperties> layerPaintProperties,
+ const std::map<std::string, PossiblyEvaluatedPaintProperties>& layerPaintProperties,
const float zoom,
const uint32_t overscaling);
~LineBucket() override;
@@ -77,8 +74,6 @@ private:
const float zoom;
const uint32_t overscaling;
-
- float getLineWidth(const RenderLineLayer& layer) const;
};
} // namespace mbgl
diff --git a/src/mbgl/renderer/group_by_layout.cpp b/src/mbgl/renderer/group_by_layout.cpp
index 41a895902c..5f78dd0d2b 100644
--- a/src/mbgl/renderer/group_by_layout.cpp
+++ b/src/mbgl/renderer/group_by_layout.cpp
@@ -1,6 +1,4 @@
#include <mbgl/renderer/group_by_layout.hpp>
-#include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/style/layer_impl.hpp>
#include <mbgl/style/conversion/stringify.hpp>
#include <mbgl/util/rapidjson.hpp>
@@ -11,38 +9,24 @@
namespace mbgl {
-std::string layoutKey(const RenderLayer& layer) {
+std::string layoutKey(const style::Layer::Impl& impl) {
using namespace style::conversion;
rapidjson::StringBuffer s;
rapidjson::Writer<rapidjson::StringBuffer> writer(s);
writer.StartArray();
- writer.Uint64(reinterpret_cast<uint64_t>(layer.baseImpl->getTypeInfo()));
- writer.String(layer.baseImpl->source);
- writer.String(layer.baseImpl->sourceLayer);
- writer.Double(layer.baseImpl->minZoom);
- writer.Double(layer.baseImpl->maxZoom);
- writer.Uint(static_cast<uint32_t>(layer.baseImpl->visibility));
- stringify(writer, layer.baseImpl->filter);
- layer.baseImpl->stringifyLayout(writer);
+ writer.Uint64(reinterpret_cast<uint64_t>(impl.getTypeInfo()));
+ writer.String(impl.source);
+ writer.String(impl.sourceLayer);
+ writer.Double(impl.minZoom);
+ writer.Double(impl.maxZoom);
+ writer.Uint(static_cast<uint32_t>(impl.visibility));
+ stringify(writer, impl.filter);
+ impl.stringifyLayout(writer);
writer.EndArray();
return s.GetString();
}
-std::vector<std::vector<const RenderLayer*>> groupByLayout(const std::vector<std::unique_ptr<RenderLayer>>& layers) {
- std::unordered_map<std::string, std::vector<const RenderLayer*>> map;
- for (auto& layer : layers) {
- map[layoutKey(*layer)].push_back(layer.get());
- }
-
- std::vector<std::vector<const RenderLayer*>> 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
index bc3ecfae63..0a91465e92 100644
--- a/src/mbgl/renderer/group_by_layout.hpp
+++ b/src/mbgl/renderer/group_by_layout.hpp
@@ -1,12 +1,12 @@
#pragma once
+#include <mbgl/style/layer_impl.hpp>
+
#include <vector>
#include <memory>
namespace mbgl {
-class RenderLayer;
-
-std::vector<std::vector<const RenderLayer*>> groupByLayout(const std::vector<std::unique_ptr<RenderLayer>>&);
+std::string layoutKey(const style::Layer::Impl& impl);
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index b633ad0671..d5ba8c879f 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -14,25 +14,30 @@ namespace mbgl {
using namespace style;
-RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const style::BackgroundLayer::Impl&>(*impl);
}
-const style::BackgroundLayer::Impl& RenderBackgroundLayer::impl() const {
- return static_cast<const style::BackgroundLayer::Impl&>(*baseImpl);
+RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
+ : RenderLayer(makeMutable<BackgroundLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
+RenderBackgroundLayer::~RenderBackgroundLayer() = default;
+
void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
- evaluated = unevaluated.evaluate(parameters);
- crossfade = parameters.getCrossfadeParameters();
-
- passes = evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
- : RenderPass::None;
+ auto properties = makeMutable<BackgroundLayerProperties>(
+ staticImmutableCast<BackgroundLayer::Impl>(baseImpl),
+ parameters.getCrossfadeParameters(),
+ unevaluated.evaluate(parameters));
+
+ passes = properties->evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
+ : RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderBackgroundLayer::hasTransition() const {
@@ -40,7 +45,7 @@ bool RenderBackgroundLayer::hasTransition() const {
}
bool RenderBackgroundLayer::hasCrossfade() const {
- return crossfade.t != 1;
+ return static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
}
void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
@@ -81,7 +86,8 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
getID()
);
};
-
+ const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
+ const auto& crossfade = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade;
if (!evaluated.get<BackgroundPattern>().to.empty()) {
optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().from);
optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().to);
@@ -123,6 +129,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
}
optional<Color> RenderBackgroundLayer::getSolidBackground() const {
+ const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
if (!evaluated.get<BackgroundPattern>().from.empty()) {
return nullopt;
}
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index 3cb30ac2a3..de553eef90 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -6,25 +6,21 @@
namespace mbgl {
-class RenderBackgroundLayer: public RenderLayer {
+class RenderBackgroundLayer final : public RenderLayer {
public:
- RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl>);
- ~RenderBackgroundLayer() final = default;
+ explicit RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl>);
+ ~RenderBackgroundLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
bool hasCrossfade() const override;
- optional<Color> getSolidBackground() const final;
+ optional<Color> getSolidBackground() const override;
void render(PaintParameters&, RenderSource*) override;
// Paint properties
style::BackgroundPaintProperties::Unevaluated unevaluated;
- style::BackgroundPaintProperties::PossiblyEvaluated evaluated;
-
- const style::BackgroundLayer::Impl& impl() const;
-private:
- CrossfadeParameters crossfade;
};
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index ad4e6a020f..9df20cf874 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -15,21 +15,24 @@ namespace mbgl {
using namespace style;
-RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const style::CircleLayer::Impl&>(*impl);
}
-const style::CircleLayer::Impl& RenderCircleLayer::impl() const {
- return static_cast<const style::CircleLayer::Impl&>(*baseImpl);
+RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
+ : RenderLayer(makeMutable<CircleLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
void RenderCircleLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
+ auto properties = makeMutable<CircleLayerProperties>(
+ staticImmutableCast<CircleLayer::Impl>(baseImpl),
+ unevaluated.evaluate(parameters));
+ const auto& evaluated = properties->evaluated;
passes = ((evaluated.get<style::CircleRadius>().constantOr(1) > 0 ||
evaluated.get<style::CircleStrokeWidth>().constantOr(1) > 0)
@@ -38,6 +41,7 @@ void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters)
&& (evaluated.get<style::CircleOpacity>().constantOr(1) > 0 ||
evaluated.get<style::CircleStrokeOpacity>().constantOr(1) > 0))
? RenderPass::Translucent : RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderCircleLayer::hasTransition() const {
@@ -52,7 +56,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
if (parameters.pass == RenderPass::Opaque) {
return;
}
-
+ const auto& evaluated = static_cast<const CircleLayerProperties&>(*evaluatedProperties).evaluated;
const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
@@ -139,7 +143,7 @@ bool RenderCircleLayer::queryIntersectsFeature(
const TransformState& transformState,
const float pixelsToTileUnits,
const mat4& posMatrix) const {
-
+ const auto& evaluated = static_cast<const CircleLayerProperties&>(*evaluatedProperties).evaluated;
// Translate query geometry
const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
queryGeometry,
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index 8b0678f6d8..fbe67c91ac 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -6,11 +6,12 @@
namespace mbgl {
-class RenderCircleLayer: public RenderLayer {
+class RenderCircleLayer final : public RenderLayer {
public:
- RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
+ explicit RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
~RenderCircleLayer() final = default;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -27,13 +28,6 @@ public:
// Paint properties
style::CirclePaintProperties::Unevaluated unevaluated;
- style::CirclePaintProperties::PossiblyEvaluated evaluated;
-
- const style::CircleLayer::Impl& impl() const;
};
-inline const RenderCircleLayer* toRenderCircleLayer(const RenderLayer* layer) {
- return static_cast<const RenderCircleLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index 9284ed8238..4148de1ddd 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -14,8 +14,13 @@ namespace mbgl {
using namespace style;
+inline const CustomLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const CustomLayer::Impl&>(*impl);
+}
+
RenderCustomLayer::RenderCustomLayer(Immutable<style::CustomLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)), host(impl().host) {
+ : RenderLayer(makeMutable<CustomLayerProperties>(std::move(_impl))),
+ host(impl(baseImpl).host) {
assert(gfx::BackendScope::exists());
MBGL_CHECK_ERROR(host->initialize());
}
@@ -29,12 +34,9 @@ RenderCustomLayer::~RenderCustomLayer() {
}
}
-const CustomLayer::Impl& RenderCustomLayer::impl() const {
- return static_cast<const CustomLayer::Impl&>(*baseImpl);
-}
-
void RenderCustomLayer::evaluate(const PropertyEvaluationParameters&) {
passes = RenderPass::Translucent;
+ // It is fine to not update `evaluatedProperties`, as `baseImpl` should never be updated for this layer.
}
bool RenderCustomLayer::hasTransition() const {
@@ -49,12 +51,12 @@ void RenderCustomLayer::markContextDestroyed() {
}
void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*) {
- if (host != impl().host) {
+ if (host != impl(baseImpl).host) {
//If the context changed, deinitialize the previous one before initializing the new one.
if (host && !contextDestroyed) {
MBGL_CHECK_ERROR(host->deinitialize());
}
- host = impl().host;
+ host = impl(baseImpl).host;
MBGL_CHECK_ERROR(host->initialize());
}
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index 37b8592172..0c364cfc0c 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -5,22 +5,20 @@
namespace mbgl {
-class RenderCustomLayer: public RenderLayer {
+class RenderCustomLayer final : public RenderLayer {
public:
- RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
- ~RenderCustomLayer() final;
+ explicit RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
+ ~RenderCustomLayer() override;
- void transition(const TransitionParameters&) final {}
+private:
+ void transition(const TransitionParameters&) override {}
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
bool hasCrossfade() const override;
- void markContextDestroyed() final;
-
- void render(PaintParameters&, RenderSource*) final;
+ void markContextDestroyed() override;
- const style::CustomLayer::Impl& impl() const;
+ void render(PaintParameters&, RenderSource*) override;
-private:
bool contextDestroyed = false;
std::shared_ptr<style::CustomLayerHost> host;
};
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 4041e420df..a313f53f1c 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -20,26 +20,31 @@ namespace mbgl {
using namespace style;
-RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const FillExtrusionLayer::Impl&>(*impl);
}
-const style::FillExtrusionLayer::Impl& RenderFillExtrusionLayer::impl() const {
- return static_cast<const style::FillExtrusionLayer::Impl&>(*baseImpl);
+RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
+ : RenderLayer(makeMutable<FillExtrusionLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
+RenderFillExtrusionLayer::~RenderFillExtrusionLayer() = default;
+
void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
- crossfade = parameters.getCrossfadeParameters();
+ auto properties = makeMutable<FillExtrusionLayerProperties>(
+ staticImmutableCast<FillExtrusionLayer::Impl>(baseImpl),
+ parameters.getCrossfadeParameters(),
+ unevaluated.evaluate(parameters));
- passes = (evaluated.get<style::FillExtrusionOpacity>() > 0)
+ passes = (properties->evaluated.get<style::FillExtrusionOpacity>() > 0)
? (RenderPass::Translucent | RenderPass::Pass3D)
: RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderFillExtrusionLayer::hasTransition() const {
@@ -47,14 +52,15 @@ bool RenderFillExtrusionLayer::hasTransition() const {
}
bool RenderFillExtrusionLayer::hasCrossfade() const {
- return crossfade.t != 1;
+ return static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
}
void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
if (parameters.pass == RenderPass::Opaque) {
return;
}
-
+ const auto& evaluated = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).evaluated;
+ const auto& crossfade = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).crossfade;
if (parameters.pass == RenderPass::Pass3D) {
const auto& size = parameters.staticData.backendSize;
@@ -222,7 +228,7 @@ bool RenderFillExtrusionLayer::queryIntersectsFeature(
const TransformState& transformState,
const float pixelsToTileUnits,
const mat4&) const {
-
+ const auto& evaluated = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).evaluated;
auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
queryGeometry,
evaluated.get<style::FillExtrusionTranslate>(),
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index 6f14fcd7a8..fa50ac6f2c 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -7,19 +7,12 @@
namespace mbgl {
-template <class B>
-class PatternLayout;
-
-class FillExtrusionBucket;
-
-class RenderFillExtrusionLayer: public RenderLayer {
+class RenderFillExtrusionLayer final : public RenderLayer {
public:
- using StyleLayerImpl = style::FillExtrusionLayer::Impl;
- using PatternProperty = style::FillExtrusionPattern;
-
- RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl>);
- ~RenderFillExtrusionLayer() final = default;
+ explicit RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl>);
+ ~RenderFillExtrusionLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -36,17 +29,8 @@ public:
// Paint properties
style::FillExtrusionPaintProperties::Unevaluated unevaluated;
- style::FillExtrusionPaintProperties::PossiblyEvaluated evaluated;
-
- const style::FillExtrusionLayer::Impl& impl() const;
std::unique_ptr<gfx::OffscreenTexture> renderTexture;
-private:
- CrossfadeParameters crossfade;
};
-inline const RenderFillExtrusionLayer* toRenderFillExtrusionLayer(const RenderLayer* layer) {
- return static_cast<const RenderFillExtrusionLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index e6447c83a4..5b0f020290 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -20,22 +20,27 @@ namespace mbgl {
using namespace style;
-RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const FillLayer::Impl&>(*impl);
}
-const style::FillLayer::Impl& RenderFillLayer::impl() const {
- return static_cast<const style::FillLayer::Impl&>(*baseImpl);
+RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
+ : RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
+RenderFillLayer::~RenderFillLayer() = default;
+
void RenderFillLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
- crossfade = parameters.getCrossfadeParameters();
+ auto properties = makeMutable<FillLayerProperties>(
+ staticImmutableCast<FillLayer::Impl>(baseImpl),
+ parameters.getCrossfadeParameters(),
+ unevaluated.evaluate(parameters));
+ auto& evaluated = properties->evaluated;
if (unevaluated.get<style::FillOutlineColor>().isUndefined()) {
evaluated.get<style::FillOutlineColor>() = evaluated.get<style::FillColor>();
@@ -54,6 +59,8 @@ void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
} else {
passes |= RenderPass::Opaque;
}
+
+ evaluatedProperties = std::move(properties);
}
bool RenderFillLayer::hasTransition() const {
@@ -61,10 +68,12 @@ bool RenderFillLayer::hasTransition() const {
}
bool RenderFillLayer::hasCrossfade() const {
- return crossfade.t != 1;
+ return static_cast<const FillLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
}
void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
+ const auto& evaluated = static_cast<const FillLayerProperties&>(*evaluatedProperties).evaluated;
+ const auto& crossfade = static_cast<const FillLayerProperties&>(*evaluatedProperties).crossfade;
if (unevaluated.get<FillPattern>().isUndefined()) {
for (const RenderTile& tile : renderTiles) {
auto bucket_ = tile.tile.getBucket<FillBucket>(*baseImpl);
@@ -240,7 +249,7 @@ bool RenderFillLayer::queryIntersectsFeature(
const TransformState& transformState,
const float pixelsToTileUnits,
const mat4&) const {
-
+ const auto& evaluated = static_cast<const FillLayerProperties&>(*evaluatedProperties).evaluated;
auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
queryGeometry,
evaluated.get<style::FillTranslate>(),
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 1c7ee6556e..5d5206efe2 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -9,14 +9,12 @@ namespace mbgl {
class FillBucket;
-class RenderFillLayer: public RenderLayer {
+class RenderFillLayer final : public RenderLayer {
public:
- using StyleLayerImpl = style::FillLayer::Impl;
- using PatternProperty = style::FillPattern;
-
- RenderFillLayer(Immutable<style::FillLayer::Impl>);
- ~RenderFillLayer() final = default;
+ explicit RenderFillLayer(Immutable<style::FillLayer::Impl>);
+ ~RenderFillLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -33,16 +31,6 @@ public:
// Paint properties
style::FillPaintProperties::Unevaluated unevaluated;
- style::FillPaintProperties::PossiblyEvaluated evaluated;
-
- const style::FillLayer::Impl& impl() const;
-private:
- CrossfadeParameters crossfade;
-
};
-inline const RenderFillLayer* toRenderFillLayer(const RenderLayer* layer) {
- return static_cast<const RenderFillLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 333b8f9890..92b54c6cc8 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -19,25 +19,31 @@ namespace mbgl {
using namespace style;
-RenderHeatmapLayer::RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()), colorRamp({256, 1}) {
+inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) {
+ return static_cast<const HeatmapLayer::Impl&>(*impl);
}
-const style::HeatmapLayer::Impl& RenderHeatmapLayer::impl() const {
- return static_cast<const style::HeatmapLayer::Impl&>(*baseImpl);
+RenderHeatmapLayer::RenderHeatmapLayer(Immutable<HeatmapLayer::Impl> _impl)
+ : RenderLayer(makeMutable<HeatmapLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()), colorRamp({256, 1}) {
}
+RenderHeatmapLayer::~RenderHeatmapLayer() = default;
+
void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderHeatmapLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
+ auto properties = makeMutable<HeatmapLayerProperties>(
+ staticImmutableCast<HeatmapLayer::Impl>(baseImpl),
+ unevaluated.evaluate(parameters));
- passes = (evaluated.get<style::HeatmapOpacity>() > 0)
+ passes = (properties->evaluated.get<style::HeatmapOpacity>() > 0)
? (RenderPass::Translucent | RenderPass::Pass3D)
: RenderPass::None;
+
+ evaluatedProperties = std::move(properties);
}
bool RenderHeatmapLayer::hasTransition() const {
@@ -52,7 +58,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
if (parameters.pass == RenderPass::Opaque) {
return;
}
-
+ const auto& evaluated = static_cast<const HeatmapLayerProperties&>(*evaluatedProperties).evaluated;
if (parameters.pass == RenderPass::Pass3D) {
const auto& viewportSize = parameters.staticData.backendSize;
const auto size = Size{viewportSize.width / 4, viewportSize.height / 4};
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index 22fe48f374..50a7d72e94 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -9,11 +9,12 @@
namespace mbgl {
-class RenderHeatmapLayer: public RenderLayer {
+class RenderHeatmapLayer final : public RenderLayer {
public:
- RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl>);
- ~RenderHeatmapLayer() final = default;
+ explicit RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl>);
+ ~RenderHeatmapLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -31,20 +32,11 @@ public:
// Paint properties
style::HeatmapPaintProperties::Unevaluated unevaluated;
- style::HeatmapPaintProperties::PossiblyEvaluated evaluated;
-
- const style::HeatmapLayer::Impl& impl() const;
-
PremultipliedImage colorRamp;
std::unique_ptr<gfx::OffscreenTexture> renderTexture;
optional<gfx::Texture> colorRampTexture;
-private:
void updateColorRamp();
};
-inline const RenderHeatmapLayer* toRenderHeatmapLayer(const RenderLayer* layer) {
- return static_cast<const RenderHeatmapLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 08efa898f6..19af5b6202 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -17,36 +17,44 @@
namespace mbgl {
using namespace style;
-RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+
+inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const HillshadeLayer::Impl&>(*impl);
}
-const style::HillshadeLayer::Impl& RenderHillshadeLayer::impl() const {
- return static_cast<const style::HillshadeLayer::Impl&>(*baseImpl);
+RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
+ : RenderLayer(makeMutable<HillshadeLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
+RenderHillshadeLayer::~RenderHillshadeLayer() = default;
+
const std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTileID& id) {
const LatLng latlng0 = LatLng(id);
const LatLng latlng1 = LatLng(UnwrappedTileID(id.canonical.z, id.canonical.x, id.canonical.y + 1));
return {{ (float)latlng0.latitude(), (float)latlng1.latitude() }};
}
-const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters){
+const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters) {
+ const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
float azimuthal = evaluated.get<HillshadeIlluminationDirection>() * util::DEG2RAD;
if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getBearing();
return {{evaluated.get<HillshadeExaggeration>(), azimuthal}};
}
void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
- passes = (evaluated.get<style::HillshadeExaggeration >() > 0)
+ auto properties = makeMutable<HillshadeLayerProperties>(
+ staticImmutableCast<HillshadeLayer::Impl>(baseImpl),
+ unevaluated.evaluate(parameters));
+ passes = (properties->evaluated.get<style::HillshadeExaggeration >() > 0)
? (RenderPass::Translucent | RenderPass::Pass3D)
: RenderPass::None;
+
+ evaluatedProperties = std::move(properties);
}
bool RenderHillshadeLayer::hasTransition() const {
@@ -60,7 +68,7 @@ bool RenderHillshadeLayer::hasCrossfade() const {
void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src) {
if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
return;
-
+ const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
auto* demsrc = static_cast<RenderRasterDEMSource*>(src);
const uint8_t TERRAIN_RGB_MAXZOOM = 15;
const uint8_t maxzoom = demsrc != nullptr ? demsrc->getMaxZoom() : TERRAIN_RGB_MAXZOOM;
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 3985389763..7c7bc10835 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -9,9 +9,10 @@ namespace mbgl {
class RenderHillshadeLayer: public RenderLayer {
public:
- RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl>);
- ~RenderHillshadeLayer() final = default;
+ explicit RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl>);
+ ~RenderHillshadeLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -21,10 +22,7 @@ public:
// Paint properties
style::HillshadePaintProperties::Unevaluated unevaluated;
- style::HillshadePaintProperties::PossiblyEvaluated evaluated;
- const style::HillshadeLayer::Impl& impl() const;
-private:
const std::array<float, 2> getLatRange(const UnwrappedTileID& id);
const std::array<float, 2> getLight(const PaintParameters& parameters);
};
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 2ea910f911..cf4d3ed9b2 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -18,28 +18,34 @@ namespace mbgl {
using namespace style;
+inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const LineLayer::Impl&>(*impl);
+}
+
RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()),
+ : RenderLayer(makeMutable<LineLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()),
colorRamp({256, 1}) {
}
-const style::LineLayer::Impl& RenderLineLayer::impl() const {
- return static_cast<const style::LineLayer::Impl&>(*baseImpl);
-}
+RenderLineLayer::~RenderLineLayer() = default;
void RenderLineLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
- crossfade = parameters.getCrossfadeParameters();
+ auto properties = makeMutable<LineLayerProperties>(
+ staticImmutableCast<LineLayer::Impl>(baseImpl),
+ parameters.getCrossfadeParameters(),
+ unevaluated.evaluate(parameters));
+ auto& evaluated = properties->evaluated;
passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
&& evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0
&& evaluated.get<style::LineWidth>().constantOr(1.0) > 0)
? RenderPass::Translucent : RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderLineLayer::hasTransition() const {
@@ -47,13 +53,15 @@ bool RenderLineLayer::hasTransition() const {
}
bool RenderLineLayer::hasCrossfade() const {
- return crossfade.t != 1;
+ return static_cast<const LineLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
}
void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
if (parameters.pass == RenderPass::Opaque) {
return;
}
+ const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
+ const auto& crossfade = static_cast<const LineLayerProperties&>(*evaluatedProperties).crossfade;
for (const RenderTile& tile : renderTiles) {
auto bucket_ = tile.tile.getBucket<LineBucket>(*baseImpl);
@@ -213,7 +221,7 @@ bool RenderLineLayer::queryIntersectsFeature(
const TransformState& transformState,
const float pixelsToTileUnits,
const mat4&) const {
-
+ const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
// Translate query geometry
auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
queryGeometry,
@@ -259,6 +267,7 @@ void RenderLineLayer::updateColorRamp() {
}
float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const {
+ const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
float lineWidth = evaluated.get<style::LineWidth>()
.evaluate(feature, zoom, style::LineWidth::defaultValue());
float gapWidth = evaluated.get<style::LineGapWidth>()
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index cb4492ebc3..da64f58455 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -10,20 +10,18 @@
namespace mbgl {
-class RenderLineLayer: public RenderLayer {
+class RenderLineLayer final : public RenderLayer {
public:
- using StyleLayerImpl = style::LineLayer::Impl;
- using PatternProperty = style::LinePattern;
-
- RenderLineLayer(Immutable<style::LineLayer::Impl>);
- ~RenderLineLayer() final = default;
+ explicit RenderLineLayer(Immutable<style::LineLayer::Impl>);
+ ~RenderLineLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
bool hasCrossfade() const override;
void render(PaintParameters&, RenderSource*) override;
- void update() final;
+ void update() override;
bool queryIntersectsFeature(
const GeometryCoordinates&,
@@ -35,20 +33,12 @@ public:
// Paint properties
style::LinePaintProperties::Unevaluated unevaluated;
- style::LinePaintProperties::PossiblyEvaluated evaluated;
-
- const style::LineLayer::Impl& impl() const;
-private:
float getLineWidth(const GeometryTileFeature&, const float) const;
void updateColorRamp();
- CrossfadeParameters crossfade;
+
PremultipliedImage colorRamp;
optional<gfx::Texture> colorRampTexture;
};
-inline const RenderLineLayer* toRenderLineLayer(const RenderLayer* layer) {
- return static_cast<const RenderLineLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 55caeaf5b0..48ca0584fc 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -14,23 +14,27 @@ namespace mbgl {
using namespace style;
-RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const RasterLayer::Impl&>(*impl);
}
-const style::RasterLayer::Impl& RenderRasterLayer::impl() const {
- return static_cast<const style::RasterLayer::Impl&>(*baseImpl);
+RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
+ : RenderLayer(makeMutable<RasterLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
+RenderRasterLayer::~RenderRasterLayer() = default;
+
void RenderRasterLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
-
- passes = evaluated.get<style::RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None;
+ auto properties = makeMutable<RasterLayerProperties>(
+ staticImmutableCast<RasterLayer::Impl>(baseImpl),
+ unevaluated.evaluate(parameters));
+ passes = properties->evaluated.get<style::RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderRasterLayer::hasTransition() const {
@@ -72,7 +76,7 @@ static std::array<float, 3> spinWeights(float spin) {
void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source) {
if (parameters.pass != RenderPass::Translucent)
return;
-
+ const auto& evaluated = static_cast<const RasterLayerProperties&>(*evaluatedProperties).evaluated;
RasterProgram::Binders paintAttributeData{ evaluated, 0 };
auto draw = [&] (const mat4& matrix,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 516c163c27..9d70e9fb4d 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -6,11 +6,12 @@
namespace mbgl {
-class RenderRasterLayer: public RenderLayer {
+class RenderRasterLayer final : public RenderLayer {
public:
- RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
- ~RenderRasterLayer() final = default;
+ explicit RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
+ ~RenderRasterLayer() override;
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -20,9 +21,6 @@ public:
// Paint properties
style::RasterPaintProperties::Unevaluated unevaluated;
- style::RasterPaintProperties::PossiblyEvaluated evaluated;
-
- const style::RasterLayer::Impl& impl() const;
};
} // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 634e0cf01b..95df9435f9 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -306,24 +306,29 @@ void drawText(const DrawFn& draw,
});
}
}
+
+inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+ return static_cast<const SymbolLayer::Impl&>(*impl);
+}
+
} // namespace
RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
- : RenderLayer(std::move(_impl)),
- unevaluated(impl().paint.untransitioned()) {
+ : RenderLayer(makeMutable<SymbolLayerProperties>(std::move(_impl))),
+ unevaluated(impl(baseImpl).paint.untransitioned()) {
}
-const style::SymbolLayer::Impl& RenderSymbolLayer::impl() const {
- return static_cast<const style::SymbolLayer::Impl&>(*baseImpl);
-}
+RenderSymbolLayer::~RenderSymbolLayer() = default;
void RenderSymbolLayer::transition(const TransitionParameters& parameters) {
- unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+ unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
- evaluated = unevaluated.evaluate(parameters);
-
+ auto properties = makeMutable<SymbolLayerProperties>(
+ staticImmutableCast<SymbolLayer::Impl>(baseImpl),
+ unevaluated.evaluate(parameters));
+ const auto& evaluated = properties->evaluated;
auto hasIconOpacity = evaluated.get<style::IconColor>().constantOr(Color::black()).a > 0 ||
evaluated.get<style::IconHaloColor>().constantOr(Color::black()).a > 0;
auto hasTextOpacity = evaluated.get<style::TextColor>().constantOr(Color::black()).a > 0 ||
@@ -332,6 +337,7 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters)
passes = ((evaluated.get<style::IconOpacity>().constantOr(1) > 0 && hasIconOpacity && iconSize > 0)
|| (evaluated.get<style::TextOpacity>().constantOr(1) > 0 && hasTextOpacity && textSize > 0))
? RenderPass::Translucent : RenderPass::None;
+ evaluatedProperties = std::move(properties);
}
bool RenderSymbolLayer::hasTransition() const {
@@ -363,7 +369,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
return;
}
- const bool sortFeaturesByKey = !impl().layout.get<SymbolSortKey>().isUndefined();
+ const bool sortFeaturesByKey = !impl(baseImpl).layout.get<SymbolSortKey>().isUndefined();
std::set<RenderableSegment> renderableSegments;
const auto draw = [&parameters, this] (auto& programInstance,
@@ -598,6 +604,7 @@ void RenderSymbolLayer::setRenderTiles(RenderTiles tiles, const TransformState&
void RenderSymbolLayer::updateBucketPaintProperties(Bucket* bucket) const {
assert(bucket->supportsLayer(*baseImpl));
+ const auto& evaluated = static_cast<const SymbolLayerProperties&>(*evaluatedProperties).evaluated;
static_cast<SymbolBucket*>(bucket)->updatePaintProperties(getID(), evaluated);
}
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 7b6d249b2e..552dd30ca2 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -53,15 +53,15 @@ public:
} // namespace style
-class BucketParameters;
-class SymbolLayout;
-class GeometryTileLayer;
-
class RenderSymbolLayer final: public RenderLayer, public RenderLayerSymbolInterface {
public:
- RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
- ~RenderSymbolLayer() final = default;
+ explicit RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
+ ~RenderSymbolLayer() override;
+ static style::IconPaintProperties::PossiblyEvaluated iconPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
+ static style::TextPaintProperties::PossiblyEvaluated textPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
+
+private:
void transition(const TransitionParameters&) override;
void evaluate(const PropertyEvaluationParameters&) override;
bool hasTransition() const override;
@@ -69,30 +69,20 @@ public:
void render(PaintParameters&, RenderSource*) override;
void setRenderTiles(RenderTiles, const TransformState&) override;
- static style::IconPaintProperties::PossiblyEvaluated iconPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
- static style::TextPaintProperties::PossiblyEvaluated textPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
-
// RenderLayerSymbolInterface overrides
- const RenderLayerSymbolInterface* getSymbolInterface() const final;
- const std::string& layerID() const final;
- const std::vector<std::reference_wrapper<RenderTile>>& getRenderTiles() const final;
- SymbolBucket* getSymbolBucket(const RenderTile&) const final;
+ const RenderLayerSymbolInterface* getSymbolInterface() const override;
+ const std::string& layerID() const override;
+ const std::vector<std::reference_wrapper<RenderTile>>& getRenderTiles() const override;
+ SymbolBucket* getSymbolBucket(const RenderTile&) const override;
// Paint properties
style::SymbolPaintProperties::Unevaluated unevaluated;
- style::SymbolPaintProperties::PossiblyEvaluated evaluated;
float iconSize = 1.0f;
float textSize = 16.0f;
- const style::SymbolLayer::Impl& impl() const;
-
protected:
void updateBucketPaintProperties(Bucket*) const final;
};
-inline const RenderSymbolLayer* toRenderSymbolLayer(const RenderLayer* layer) {
- return static_cast<const RenderSymbolLayer*>(layer);
-}
-
} // namespace mbgl
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index 24a45b9146..c2719fef91 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -10,8 +10,9 @@ namespace mbgl {
using namespace style;
-RenderLayer::RenderLayer(Immutable<style::Layer::Impl> baseImpl_)
- : baseImpl(std::move(baseImpl_)) {
+RenderLayer::RenderLayer(Immutable<style::LayerProperties> properties)
+ : evaluatedProperties(std::move(properties)),
+ baseImpl(evaluatedProperties->baseImpl) {
}
void RenderLayer::setImpl(Immutable<style::Layer::Impl> impl) {
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 98e151435a..9654b9213f 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -1,7 +1,7 @@
#pragma once
#include <mbgl/layout/layout.hpp>
#include <mbgl/renderer/render_pass.hpp>
-#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <mbgl/util/mat4.hpp>
@@ -11,7 +11,6 @@
namespace mbgl {
class Bucket;
-class BucketParameters;
class TransitionParameters;
class PropertyEvaluationParameters;
class PaintParameters;
@@ -22,7 +21,7 @@ class TransformState;
class RenderLayer {
protected:
- RenderLayer(Immutable<style::Layer::Impl>);
+ RenderLayer(Immutable<style::LayerProperties>);
public:
virtual ~RenderLayer() = default;
@@ -31,6 +30,7 @@ public:
virtual void transition(const TransitionParameters&) = 0;
// Fully evaluate possibly-transitioning paint properties based on a zoom level.
+ // Updates the contained `evaluatedProperties` member.
virtual void evaluate(const PropertyEvaluationParameters&) = 0;
// Returns true if any paint properties have active transitions.
@@ -65,6 +65,8 @@ public:
using RenderTiles = std::vector<std::reference_wrapper<RenderTile>>;
virtual void setRenderTiles(RenderTiles, const TransformState&);
+ // Latest evaluated properties.
+ Immutable<style::LayerProperties> evaluatedProperties;
// Private implementation
Immutable<style::Layer::Impl> baseImpl;
void setImpl(Immutable<style::Layer::Impl>);
diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp
index 1ebf1b53f1..d8b8a7f286 100644
--- a/src/mbgl/style/layers/custom_layer_impl.hpp
+++ b/src/mbgl/style/layers/custom_layer_impl.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
#include <mbgl/style/layers/custom_layer.hpp>
#include <memory>
@@ -24,5 +25,11 @@ public:
DECLARE_LAYER_TYPE_INFO;
};
+class CustomLayerProperties final : public LayerProperties {
+public:
+ explicit CustomLayerProperties(Immutable<CustomLayer::Impl> impl)
+ : LayerProperties(std::move(impl)) {}
+};
+
} // namespace style
} // namespace mbgl
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index 0c8b7a4ca1..56f6401ce7 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -312,22 +312,23 @@ void GeometryTileWorker::requestNewImages(const ImageDependencies& imageDependen
}
}
-static std::vector<std::unique_ptr<RenderLayer>> toRenderLayers(const std::vector<Immutable<style::Layer::Impl>>& layers, float zoom) {
- std::vector<std::unique_ptr<RenderLayer>> renderLayers;
- renderLayers.reserve(layers.size());
+static std::vector<Immutable<style::LayerProperties>> toEvaluatedProperties(const std::vector<Immutable<style::Layer::Impl>>& layers, float zoom) {
+ std::vector<Immutable<style::LayerProperties>> result;
+ result.reserve(layers.size());
for (auto& layer : layers) {
- renderLayers.push_back(LayerManager::get()->createRenderLayer(layer));
+ auto renderLayer = LayerManager::get()->createRenderLayer(layer);
- renderLayers.back()->transition(TransitionParameters {
+ renderLayer->transition(TransitionParameters {
Clock::time_point::max(),
TransitionOptions()
});
- renderLayers.back()->evaluate(PropertyEvaluationParameters {
+ renderLayer->evaluate(PropertyEvaluationParameters {
zoom
});
+ result.push_back(renderLayer->evaluatedProperties);
}
- return renderLayers;
+ return result;
}
void GeometryTileWorker::parse() {
@@ -348,10 +349,14 @@ void GeometryTileWorker::parse() {
ImageDependencies imageDependencies;
// Create render layers and group by layout
- std::vector<std::unique_ptr<RenderLayer>> renderLayers = toRenderLayers(*layers, id.overscaledZ);
- std::vector<std::vector<const RenderLayer*>> groups = groupByLayout(renderLayers);
+ std::vector<Immutable<style::LayerProperties>> evaluatedProperties = toEvaluatedProperties(*layers, id.overscaledZ);
+ std::unordered_map<std::string, std::vector<Immutable<style::LayerProperties>>> groupMap;
+ for (auto layer : evaluatedProperties) {
+ groupMap[layoutKey(*layer->baseImpl)].push_back(std::move(layer));
+ }
- for (auto& group : groups) {
+ for (auto& pair : groupMap) {
+ const auto& group = pair.second;
if (obsolete) {
return;
}
@@ -360,35 +365,35 @@ void GeometryTileWorker::parse() {
continue; // Tile has no data.
}
- const RenderLayer& leader = *group.at(0);
- BucketParameters parameters { id, mode, pixelRatio, leader.baseImpl->getTypeInfo() };
+ const style::Layer::Impl& leaderImpl = *(group.at(0)->baseImpl);
+ BucketParameters parameters { id, mode, pixelRatio, leaderImpl.getTypeInfo() };
- auto geometryLayer = (*data)->getLayer(leader.baseImpl->sourceLayer);
+ auto geometryLayer = (*data)->getLayer(leaderImpl.sourceLayer);
if (!geometryLayer) {
continue;
}
- std::vector<std::string> layerIDs;
+ std::vector<std::string> layerIDs(group.size());
for (const auto& layer : group) {
- layerIDs.push_back(layer->getID());
+ layerIDs.push_back(layer->baseImpl->id);
}
- featureIndex->setBucketLayerIDs(leader.getID(), layerIDs);
+ featureIndex->setBucketLayerIDs(leaderImpl.id, layerIDs);
// Symbol layers and layers that support pattern properties have an extra step at layout time to figure out what images/glyphs
// are needed to render the layer. They use the intermediate Layout data structure to accomplish this,
// and either immediately create a bucket if no images/glyphs are used, or the Layout is stored until
// the images/glyphs are available to add the features to the buckets.
- if (leader.baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::Required) {
- auto layout = LayerManager::get()->createLayout({parameters, glyphDependencies, imageDependencies}, std::move(geometryLayer), group);
+ if (leaderImpl.getTypeInfo()->layout == LayerTypeInfo::Layout::Required) {
+ std::unique_ptr<Layout> layout = LayerManager::get()->createLayout({parameters, glyphDependencies, imageDependencies}, std::move(geometryLayer), group);
if (layout->hasDependencies()) {
layouts.push_back(std::move(layout));
} else {
layout->createBucket({}, featureIndex, buckets, firstLoad, showCollisionBoxes);
}
} else {
- const Filter& filter = leader.baseImpl->filter;
- const std::string& sourceLayerID = leader.baseImpl->sourceLayer;
+ const Filter& filter = leaderImpl.filter;
+ const std::string& sourceLayerID = leaderImpl.sourceLayer;
std::shared_ptr<Bucket> bucket = LayerManager::get()->createBucket(parameters, group);
for (std::size_t i = 0; !obsolete && i < geometryLayer->featureCount(); i++) {
@@ -399,7 +404,7 @@ void GeometryTileWorker::parse() {
GeometryCollection geometries = feature->getGeometries();
bucket->addFeature(*feature, geometries, {}, PatternLayerMap ());
- featureIndex->insert(geometries, i, sourceLayerID, leader.getID());
+ featureIndex->insert(geometries, i, sourceLayerID, leaderImpl.id);
}
if (!bucket->hasData()) {
@@ -407,7 +412,7 @@ void GeometryTileWorker::parse() {
}
for (const auto& layer : group) {
- buckets.emplace(layer->getID(), bucket);
+ buckets.emplace(layer->baseImpl->id, bucket);
}
}
}
diff --git a/src/mbgl/tile/geometry_tile_worker.hpp b/src/mbgl/tile/geometry_tile_worker.hpp
index 4402875603..fb841c63be 100644
--- a/src/mbgl/tile/geometry_tile_worker.hpp
+++ b/src/mbgl/tile/geometry_tile_worker.hpp
@@ -20,9 +20,6 @@ class GeometryTile;
class GeometryTileData;
class Layout;
-template <class B>
-class PatternLayout;
-
namespace style {
class Layer;
} // namespace style
diff --git a/test/renderer/group_by_layout.test.cpp b/test/renderer/group_by_layout.test.cpp
deleted file mode 100644
index d1a7a0bf5f..0000000000
--- a/test/renderer/group_by_layout.test.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <mbgl/test/util.hpp>
-
-#include <mbgl/layermanager/layer_manager.hpp>
-#include <mbgl/renderer/group_by_layout.hpp>
-#include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/style/layers/background_layer.hpp>
-#include <mbgl/style/layers/circle_layer.hpp>
-#include <mbgl/style/layers/line_layer.hpp>
-#include <mbgl/style/expression/dsl.hpp>
-
-using namespace mbgl;
-using namespace mbgl::style;
-using namespace mbgl::style::expression;
-
-static std::vector<std::unique_ptr<RenderLayer>> toRenderLayers(const std::vector<std::unique_ptr<Layer>>& layers) {
- std::vector<std::unique_ptr<RenderLayer>> result;
- result.reserve(layers.size());
- for (auto& layer : layers) {
- result.push_back(LayerManager::get()->createRenderLayer(layer->baseImpl));
- }
- return result;
-}
-
-TEST(GroupByLayout, Related) {
- std::vector<std::unique_ptr<Layer>> layers;
- layers.push_back(std::make_unique<LineLayer>("a", "source"));
- layers.push_back(std::make_unique<LineLayer>("b", "source"));
- auto result = groupByLayout(toRenderLayers(layers));
- ASSERT_EQ(1u, result.size());
- ASSERT_EQ(2u, result[0].size());
-}
-
-TEST(GroupByLayout, UnrelatedType) {
- std::vector<std::unique_ptr<Layer>> layers;
- layers.push_back(std::make_unique<BackgroundLayer>("background"));
- layers.push_back(std::make_unique<CircleLayer>("circle", "source"));
- auto result = groupByLayout(toRenderLayers(layers));
- ASSERT_EQ(2u, result.size());
-}
-
-TEST(GroupByLayout, UnrelatedFilter) {
- using namespace mbgl::style::expression::dsl;
- std::vector<std::unique_ptr<Layer>> layers;
- auto lineLayer = std::make_unique<LineLayer>("a", "source");
- lineLayer->setFilter(Filter(get("property")));
- layers.push_back(std::move(lineLayer));
- layers.push_back(std::make_unique<LineLayer>("b", "source"));
- auto result = groupByLayout(toRenderLayers(layers));
- ASSERT_EQ(2u, result.size());
-}
-
-TEST(GroupByLayout, UnrelatedLayout) {
- std::vector<std::unique_ptr<Layer>> layers;
- auto lineLayer = std::make_unique<LineLayer>("a", "source");
- lineLayer->setLineCap(LineCapType::Square);
- layers.push_back(std::move(lineLayer));
- layers.push_back(std::make_unique<LineLayer>("b", "source"));
- auto result = groupByLayout(toRenderLayers(layers));
- ASSERT_EQ(2u, result.size());
-}
diff --git a/test/test-files.json b/test/test-files.json
index 0ba0a07577..df46689d50 100644
--- a/test/test-files.json
+++ b/test/test-files.json
@@ -28,7 +28,6 @@
"test/programs/binary_program.test.cpp",
"test/programs/symbol_program.test.cpp",
"test/renderer/backend_scope.test.cpp",
- "test/renderer/group_by_layout.test.cpp",
"test/renderer/image_manager.test.cpp",
"test/sprite/sprite_loader.test.cpp",
"test/sprite/sprite_parser.test.cpp",