summaryrefslogtreecommitdiff
path: root/src/mbgl/layer
diff options
context:
space:
mode:
Diffstat (limited to 'src/mbgl/layer')
-rw-r--r--src/mbgl/layer/background_layer.cpp31
-rw-r--r--src/mbgl/layer/background_layer.hpp18
-rw-r--r--src/mbgl/layer/circle_layer.cpp46
-rw-r--r--src/mbgl/layer/circle_layer.hpp25
-rw-r--r--src/mbgl/layer/fill_layer.cpp59
-rw-r--r--src/mbgl/layer/fill_layer.hpp22
-rw-r--r--src/mbgl/layer/line_layer.cpp76
-rw-r--r--src/mbgl/layer/line_layer.hpp31
-rw-r--r--src/mbgl/layer/raster_layer.cpp57
-rw-r--r--src/mbgl/layer/raster_layer.hpp22
-rw-r--r--src/mbgl/layer/symbol_layer.cpp113
-rw-r--r--src/mbgl/layer/symbol_layer.hpp37
12 files changed, 290 insertions, 247 deletions
diff --git a/src/mbgl/layer/background_layer.cpp b/src/mbgl/layer/background_layer.cpp
index 0a86e2db14..51000e53ba 100644
--- a/src/mbgl/layer/background_layer.cpp
+++ b/src/mbgl/layer/background_layer.cpp
@@ -1,5 +1,4 @@
#include <mbgl/layer/background_layer.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/renderer/bucket.hpp>
namespace mbgl {
@@ -7,34 +6,32 @@ namespace mbgl {
std::unique_ptr<StyleLayer> BackgroundLayer::clone() const {
std::unique_ptr<BackgroundLayer> result = std::make_unique<BackgroundLayer>();
result->copy(*this);
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
void BackgroundLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<float>>("background-opacity", PropertyKey::BackgroundOpacity, paint, value);
- parseProperty<Function<Color>>("background-color", PropertyKey::BackgroundColor, paint, value);
- parseProperty<Function<Faded<std::string>>>("background-pattern", PropertyKey::BackgroundImage, paint, value);
- });
+ paint.opacity.parse("background-opacity", layer);
+ paint.color.parse("background-color", layer);
+ paint.pattern.parse("background-pattern", layer);
}
void BackgroundLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
+ paint.opacity.cascade(parameters);
+ paint.color.cascade(parameters);
+ paint.pattern.cascade(parameters);
}
-bool BackgroundLayer::hasTransitions() const {
- return paints.hasTransitions();
-}
+bool BackgroundLayer::recalculate(const StyleCalculationParameters& parameters) {
+ bool hasTransitions = false;
-void BackgroundLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
+ hasTransitions |= paint.opacity.calculate(parameters);
+ hasTransitions |= paint.color.calculate(parameters);
+ hasTransitions |= paint.pattern.calculate(parameters);
- paints.calculateTransitioned(PropertyKey::BackgroundOpacity, properties.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::BackgroundColor, properties.color, parameters);
- paints.calculate(PropertyKey::BackgroundImage, properties.image, parameters);
+ passes = paint.opacity > 0 ? RenderPass::Translucent : RenderPass::None;
- passes = properties.isVisible() ? RenderPass::Translucent : RenderPass::None;
+ return hasTransitions;
}
std::unique_ptr<Bucket> BackgroundLayer::createBucket(StyleBucketParameters&) const {
diff --git a/src/mbgl/layer/background_layer.hpp b/src/mbgl/layer/background_layer.hpp
index 11d06b2cd2..a65b9e0183 100644
--- a/src/mbgl/layer/background_layer.hpp
+++ b/src/mbgl/layer/background_layer.hpp
@@ -2,11 +2,17 @@
#define MBGL_BACKGROUND_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
+class BackgroundPaintProperties {
+public:
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<Color> color = { {{ 0, 0, 0, 1 }} };
+ PaintProperty<std::string, Faded<std::string>> pattern = { "" };
+};
+
class BackgroundLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -15,15 +21,11 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
- PaintPropertiesMap paints;
-
- BackgroundPaintProperties properties;
+ BackgroundPaintProperties paint;
};
}
diff --git a/src/mbgl/layer/circle_layer.cpp b/src/mbgl/layer/circle_layer.cpp
index 7680136555..e33476a4a8 100644
--- a/src/mbgl/layer/circle_layer.cpp
+++ b/src/mbgl/layer/circle_layer.cpp
@@ -1,5 +1,4 @@
#include <mbgl/layer/circle_layer.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/style/style_bucket_parameters.hpp>
#include <mbgl/renderer/circle_bucket.hpp>
@@ -8,40 +7,41 @@ namespace mbgl {
std::unique_ptr<StyleLayer> CircleLayer::clone() const {
std::unique_ptr<CircleLayer> result = std::make_unique<CircleLayer>();
result->copy(*this);
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
void CircleLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<float>>("circle-radius", PropertyKey::CircleRadius, paint, value);
- parseProperty<Function<Color>>("circle-color", PropertyKey::CircleColor, paint, value);
- parseProperty<Function<float>>("circle-opacity", PropertyKey::CircleOpacity, paint, value);
- parseProperty<Function<std::array<float,2>>>("circle-translate", PropertyKey::CircleTranslate, paint, value);
- parseProperty<Function<TranslateAnchorType>>("circle-translate-anchor", PropertyKey::CircleTranslateAnchor, paint, value);
- parseProperty<Function<float>>("circle-blur", PropertyKey::CircleBlur, paint, value);
- });
+ paint.radius.parse("circle-radius", layer);
+ paint.color.parse("circle-color", layer);
+ paint.opacity.parse("circle-opacity", layer);
+ paint.translate.parse("circle-translate", layer);
+ paint.translateAnchor.parse("circle-translate-anchor", layer);
+ paint.blur.parse("circle-blur", layer);
}
void CircleLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
+ paint.radius.cascade(parameters);
+ paint.color.cascade(parameters);
+ paint.opacity.cascade(parameters);
+ paint.translate.cascade(parameters);
+ paint.translateAnchor.cascade(parameters);
+ paint.blur.cascade(parameters);
}
-bool CircleLayer::hasTransitions() const {
- return paints.hasTransitions();
-}
+bool CircleLayer::recalculate(const StyleCalculationParameters& parameters) {
+ bool hasTransitions = false;
-void CircleLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
+ hasTransitions |= paint.radius.calculate(parameters);
+ hasTransitions |= paint.color.calculate(parameters);
+ hasTransitions |= paint.opacity.calculate(parameters);
+ hasTransitions |= paint.translate.calculate(parameters);
+ hasTransitions |= paint.translateAnchor.calculate(parameters);
+ hasTransitions |= paint.blur.calculate(parameters);
- paints.calculateTransitioned(PropertyKey::CircleRadius, properties.radius, parameters);
- paints.calculateTransitioned(PropertyKey::CircleColor, properties.color, parameters);
- paints.calculateTransitioned(PropertyKey::CircleOpacity, properties.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::CircleTranslate, properties.translate, parameters);
- paints.calculate(PropertyKey::CircleTranslateAnchor, properties.translateAnchor, parameters);
- paints.calculateTransitioned(PropertyKey::CircleBlur, properties.blur, parameters);
+ passes = paint.isVisible() ? RenderPass::Translucent : RenderPass::None;
- passes = properties.isVisible() ? RenderPass::Translucent : RenderPass::None;
+ return hasTransitions;
}
std::unique_ptr<Bucket> CircleLayer::createBucket(StyleBucketParameters& parameters) const {
diff --git a/src/mbgl/layer/circle_layer.hpp b/src/mbgl/layer/circle_layer.hpp
index 29cdf513df..eac9a915cc 100644
--- a/src/mbgl/layer/circle_layer.hpp
+++ b/src/mbgl/layer/circle_layer.hpp
@@ -2,11 +2,24 @@
#define MBGL_CIRCLE_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
+class CirclePaintProperties {
+public:
+ PaintProperty<float> radius = 5.0f;
+ PaintProperty<Color> color = { {{ 0, 0, 0, 1 }} };
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<std::array<float, 2>> translate = { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> translateAnchor = TranslateAnchorType::Map;
+ PaintProperty<float> blur = 0;
+
+ bool isVisible() const {
+ return radius > 0 && color.value[3] > 0 && opacity > 0;
+ }
+};
+
class CircleLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -15,15 +28,11 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
- PaintPropertiesMap paints;
-
- CirclePaintProperties properties;
+ CirclePaintProperties paint;
};
}
diff --git a/src/mbgl/layer/fill_layer.cpp b/src/mbgl/layer/fill_layer.cpp
index ad68a240fc..52a6b8fe55 100644
--- a/src/mbgl/layer/fill_layer.cpp
+++ b/src/mbgl/layer/fill_layer.cpp
@@ -1,5 +1,4 @@
#include <mbgl/layer/fill_layer.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/style/style_bucket_parameters.hpp>
#include <mbgl/renderer/fill_bucket.hpp>
@@ -8,56 +7,54 @@ namespace mbgl {
std::unique_ptr<StyleLayer> FillLayer::clone() const {
std::unique_ptr<FillLayer> result = std::make_unique<FillLayer>();
result->copy(*this);
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
void FillLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<bool>>("fill-antialias", PropertyKey::FillAntialias, paint, value);
- parseProperty<Function<float>>("fill-opacity", PropertyKey::FillOpacity, paint, value);
- parseProperty<PropertyTransition>("fill-opacity-transition", PropertyKey::FillOpacity, paint, value);
- parseProperty<Function<Color>>("fill-color", PropertyKey::FillColor, paint, value);
- parseProperty<PropertyTransition>("fill-color-transition", PropertyKey::FillColor, paint, value);
- parseProperty<Function<Color>>("fill-outline-color", PropertyKey::FillOutlineColor, paint, value);
- parseProperty<PropertyTransition>("fill-outline-color-transition", PropertyKey::FillOutlineColor, paint, value);
- parseProperty<Function<std::array<float, 2>>>("fill-translate", PropertyKey::FillTranslate, paint, value);
- parseProperty<PropertyTransition>("fill-translate-transition", PropertyKey::FillTranslate, paint, value);
- parseProperty<Function<TranslateAnchorType>>("fill-translate-anchor", PropertyKey::FillTranslateAnchor, paint, value);
- parseProperty<Function<Faded<std::string>>>("fill-pattern", PropertyKey::FillImage, paint, value);
- });
+ paint.antialias.parse("fill-antialias", layer);
+ paint.opacity.parse("fill-opacity", layer);
+ paint.color.parse("fill-color", layer);
+ paint.outlineColor.parse("fill-outline-color", layer);
+ paint.translate.parse("fill-translate", layer);
+ paint.translateAnchor.parse("fill-translate-anchor", layer);
+ paint.pattern.parse("fill-pattern", layer);
}
void FillLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
-}
-
-bool FillLayer::hasTransitions() const {
- return paints.hasTransitions();
+ paint.antialias.cascade(parameters);
+ paint.opacity.cascade(parameters);
+ paint.color.cascade(parameters);
+ paint.outlineColor.cascade(parameters);
+ paint.translate.cascade(parameters);
+ paint.translateAnchor.cascade(parameters);
+ paint.pattern.cascade(parameters);
}
-void FillLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
+bool FillLayer::recalculate(const StyleCalculationParameters& parameters) {
+ bool hasTransitions = false;
- paints.calculate(PropertyKey::FillAntialias, properties.antialias, parameters);
- paints.calculateTransitioned(PropertyKey::FillOpacity, properties.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::FillColor, properties.fill_color, parameters);
- paints.calculateTransitioned(PropertyKey::FillOutlineColor, properties.stroke_color, parameters);
- paints.calculateTransitioned(PropertyKey::FillTranslate, properties.translate, parameters);
- paints.calculate(PropertyKey::FillTranslateAnchor, properties.translateAnchor, parameters);
- paints.calculate(PropertyKey::FillImage, properties.image, parameters);
+ hasTransitions |= paint.antialias.calculate(parameters);
+ hasTransitions |= paint.opacity.calculate(parameters);
+ hasTransitions |= paint.color.calculate(parameters);
+ hasTransitions |= paint.outlineColor.calculate(parameters);
+ hasTransitions |= paint.translate.calculate(parameters);
+ hasTransitions |= paint.translateAnchor.calculate(parameters);
+ hasTransitions |= paint.pattern.calculate(parameters);
passes = RenderPass::None;
- if (properties.antialias) {
+ if (paint.antialias) {
passes |= RenderPass::Translucent;
}
- if (!properties.image.from.empty() || (properties.fill_color[3] * properties.opacity) < 1.0f) {
+ if (!paint.pattern.value.from.empty() || (paint.color.value[3] * paint.opacity) < 1.0f) {
passes |= RenderPass::Translucent;
} else {
passes |= RenderPass::Opaque;
}
+
+ return hasTransitions;
}
std::unique_ptr<Bucket> FillLayer::createBucket(StyleBucketParameters& parameters) const {
diff --git a/src/mbgl/layer/fill_layer.hpp b/src/mbgl/layer/fill_layer.hpp
index 5a543889c5..c0ed228d48 100644
--- a/src/mbgl/layer/fill_layer.hpp
+++ b/src/mbgl/layer/fill_layer.hpp
@@ -2,11 +2,21 @@
#define MBGL_FILL_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
+class FillPaintProperties {
+public:
+ PaintProperty<bool> antialias = true;
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<Color> color = { {{ 0, 0, 0, 1 }} };
+ PaintProperty<Color> outlineColor = { {{ 0, 0, 0, -1 }} };
+ PaintProperty<std::array<float, 2>> translate = { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> translateAnchor = TranslateAnchorType::Map;
+ PaintProperty<std::string, Faded<std::string>> pattern = { "" };
+};
+
class FillLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -15,15 +25,11 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
- PaintPropertiesMap paints;
-
- FillPaintProperties properties;
+ FillPaintProperties paint;
};
}
diff --git a/src/mbgl/layer/line_layer.cpp b/src/mbgl/layer/line_layer.cpp
index fa1f22d5f7..f4453f819d 100644
--- a/src/mbgl/layer/line_layer.cpp
+++ b/src/mbgl/layer/line_layer.cpp
@@ -1,5 +1,4 @@
#include <mbgl/layer/line_layer.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/style/style_bucket_parameters.hpp>
#include <mbgl/renderer/line_bucket.hpp>
#include <mbgl/map/tile_id.hpp>
@@ -10,7 +9,7 @@ std::unique_ptr<StyleLayer> LineLayer::clone() const {
std::unique_ptr<LineLayer> result = std::make_unique<LineLayer>();
result->copy(*this);
result->layout = layout;
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
@@ -22,52 +21,51 @@ void LineLayer::parseLayout(const JSVal& value) {
}
void LineLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<float>>("line-opacity", PropertyKey::LineOpacity, paint, value);
- parseProperty<PropertyTransition>("line-opacity-transition", PropertyKey::LineOpacity, paint, value);
- parseProperty<Function<Color>>("line-color", PropertyKey::LineColor, paint, value);
- parseProperty<PropertyTransition>("line-color-transition", PropertyKey::LineColor, paint, value);
- parseProperty<Function<std::array<float,2>>>("line-translate", PropertyKey::LineTranslate, paint, value);
- parseProperty<PropertyTransition>("line-translate-transition", PropertyKey::LineTranslate, paint, value);
- parseProperty<Function<TranslateAnchorType>>("line-translate-anchor", PropertyKey::LineTranslateAnchor, paint, value);
- parseProperty<Function<float>>("line-width", PropertyKey::LineWidth, paint, value);
- parseProperty<PropertyTransition>("line-width-transition", PropertyKey::LineWidth, paint, value);
- parseProperty<Function<float>>("line-gap-width", PropertyKey::LineGapWidth, paint, value);
- parseProperty<PropertyTransition>("line-gap-width-transition", PropertyKey::LineGapWidth, paint, value);
- parseProperty<Function<float>>("line-blur", PropertyKey::LineBlur, paint, value);
- parseProperty<PropertyTransition>("line-blur-transition", PropertyKey::LineBlur, paint, value);
- parseProperty<Function<Faded<std::vector<float>>>>("line-dasharray", PropertyKey::LineDashArray, paint, value);
- parseProperty<Function<Faded<std::string>>>("line-pattern", PropertyKey::LineImage, paint, value);
- });
+ paint.opacity.parse("line-opacity", layer);
+ paint.color.parse("line-color", layer);
+ paint.translate.parse("line-translate", layer);
+ paint.translateAnchor.parse("line-translate-anchor", layer);
+ paint.width.parse("line-width", layer);
+ paint.gapWidth.parse("line-gap-width", layer);
+ paint.blur.parse("line-blur", layer);
+ paint.dasharray.parse("line-dasharray", layer);
+ paint.pattern.parse("line-pattern", layer);
}
void LineLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
-}
-
-bool LineLayer::hasTransitions() const {
- return paints.hasTransitions();
+ paint.opacity.cascade(parameters);
+ paint.color.cascade(parameters);
+ paint.translate.cascade(parameters);
+ paint.translateAnchor.cascade(parameters);
+ paint.width.cascade(parameters);
+ paint.gapWidth.cascade(parameters);
+ paint.blur.cascade(parameters);
+ paint.dasharray.cascade(parameters);
+ paint.pattern.cascade(parameters);
}
-void LineLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
-
- paints.calculateTransitioned(PropertyKey::LineOpacity, properties.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::LineColor, properties.color, parameters);
- paints.calculateTransitioned(PropertyKey::LineTranslate, properties.translate, parameters);
- paints.calculate(PropertyKey::LineTranslateAnchor, properties.translateAnchor, parameters);
- paints.calculateTransitioned(PropertyKey::LineWidth, properties.width, parameters);
- paints.calculateTransitioned(PropertyKey::LineGapWidth, properties.gap_width, parameters);
- paints.calculateTransitioned(PropertyKey::LineBlur, properties.blur, parameters);
- paints.calculate(PropertyKey::LineDashArray, properties.dash_array, parameters);
- paints.calculate(PropertyKey::LineImage, properties.image, parameters);
-
+bool LineLayer::recalculate(const StyleCalculationParameters& parameters) {
// for scaling dasharrays
StyleCalculationParameters dashArrayParams = parameters;
dashArrayParams.z = std::floor(dashArrayParams.z);
- paints.calculate(PropertyKey::LineWidth, properties.dash_line_width, dashArrayParams);
+ paint.width.calculate(dashArrayParams);
+ paint.dashLineWidth = paint.width;
+
+ bool hasTransitions = false;
+
+ hasTransitions |= paint.opacity.calculate(parameters);
+ hasTransitions |= paint.color.calculate(parameters);
+ hasTransitions |= paint.translate.calculate(parameters);
+ hasTransitions |= paint.translateAnchor.calculate(parameters);
+ hasTransitions |= paint.width.calculate(parameters);
+ hasTransitions |= paint.gapWidth.calculate(parameters);
+ hasTransitions |= paint.blur.calculate(parameters);
+ hasTransitions |= paint.dasharray.calculate(parameters);
+ hasTransitions |= paint.pattern.calculate(parameters);
+
+ passes = paint.isVisible() ? RenderPass::Translucent : RenderPass::None;
- passes = properties.isVisible() ? RenderPass::Translucent : RenderPass::None;
+ return hasTransitions;
}
std::unique_ptr<Bucket> LineLayer::createBucket(StyleBucketParameters& parameters) const {
diff --git a/src/mbgl/layer/line_layer.hpp b/src/mbgl/layer/line_layer.hpp
index d35461131e..639ba34f57 100644
--- a/src/mbgl/layer/line_layer.hpp
+++ b/src/mbgl/layer/line_layer.hpp
@@ -2,9 +2,8 @@
#define MBGL_LINE_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
#include <mbgl/style/layout_property.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
@@ -16,6 +15,26 @@ public:
LayoutProperty<float> roundLimit = 1.0f;
};
+class LinePaintProperties {
+public:
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<Color> color = { {{ 0, 0, 0, 1 }} };
+ PaintProperty<std::array<float, 2>> translate = { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> translateAnchor = TranslateAnchorType::Map;
+ PaintProperty<float> width = 1;
+ PaintProperty<float> gapWidth = 0;
+ PaintProperty<float> blur = 0;
+ PaintProperty<std::vector<float>, Faded<std::vector<float>>> dasharray = { {} };
+ PaintProperty<std::string, Faded<std::string>> pattern = { "" };
+
+ // Special case
+ float dashLineWidth = 1;
+
+ bool isVisible() const {
+ return opacity > 0 && color.value[3] > 0 && width > 0;
+ }
+};
+
class LineLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -24,16 +43,12 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
LineLayoutProperties layout;
- PaintPropertiesMap paints;
-
- LinePaintProperties properties;
+ LinePaintProperties paint;
};
}
diff --git a/src/mbgl/layer/raster_layer.cpp b/src/mbgl/layer/raster_layer.cpp
index 3e3536afc3..5a7e686441 100644
--- a/src/mbgl/layer/raster_layer.cpp
+++ b/src/mbgl/layer/raster_layer.cpp
@@ -1,5 +1,4 @@
#include <mbgl/layer/raster_layer.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/renderer/bucket.hpp>
namespace mbgl {
@@ -7,48 +6,44 @@ namespace mbgl {
std::unique_ptr<StyleLayer> RasterLayer::clone() const {
std::unique_ptr<RasterLayer> result = std::make_unique<RasterLayer>();
result->copy(*this);
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
void RasterLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<float>>("raster-opacity", PropertyKey::RasterOpacity, paint, value);
- parseProperty<PropertyTransition>("raster-opacity-transition", PropertyKey::RasterOpacity, paint, value);
- parseProperty<Function<float>>("raster-hue-rotate", PropertyKey::RasterHueRotate, paint, value);
- parseProperty<PropertyTransition>("raster-hue-rotate-transition", PropertyKey::RasterHueRotate, paint, value);
- parseProperty<Function<float>>("raster-brightness-min", PropertyKey::RasterBrightnessLow, paint, value);
- parseProperty<Function<float>>("raster-brightness-max", PropertyKey::RasterBrightnessHigh, paint, value);
- parseProperty<PropertyTransition>("raster-brightness-transition", PropertyKey::RasterBrightness, paint, value);
- parseProperty<Function<float>>("raster-saturation", PropertyKey::RasterSaturation, paint, value);
- parseProperty<PropertyTransition>("raster-saturation-transition", PropertyKey::RasterSaturation, paint, value);
- parseProperty<Function<float>>("raster-contrast", PropertyKey::RasterContrast, paint, value);
- parseProperty<PropertyTransition>("raster-contrast-transition", PropertyKey::RasterContrast, paint, value);
- parseProperty<Function<float>>("raster-fade-duration", PropertyKey::RasterFade, paint, value);
- parseProperty<PropertyTransition>("raster-fade-duration-transition", PropertyKey::RasterFade, paint, value);
- });
+ paint.opacity.parse("raster-opacity", layer);
+ paint.hueRotate.parse("raster-hue-rotate", layer);
+ paint.brightnessMin.parse("raster-brightness-min", layer);
+ paint.brightnessMax.parse("raster-brightness-max", layer);
+ paint.saturation.parse("raster-saturation", layer);
+ paint.contrast.parse("raster-contrast", layer);
+ paint.fadeDuration.parse("raster-fade-duration", layer);
}
void RasterLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
+ paint.opacity.cascade(parameters);
+ paint.hueRotate.cascade(parameters);
+ paint.brightnessMin.cascade(parameters);
+ paint.brightnessMax.cascade(parameters);
+ paint.saturation.cascade(parameters);
+ paint.contrast.cascade(parameters);
+ paint.fadeDuration.cascade(parameters);
}
-bool RasterLayer::hasTransitions() const {
- return paints.hasTransitions();
-}
+bool RasterLayer::recalculate(const StyleCalculationParameters& parameters) {
+ bool hasTransitions = false;
-void RasterLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
+ hasTransitions |= paint.opacity.calculate(parameters);
+ hasTransitions |= paint.hueRotate.calculate(parameters);
+ hasTransitions |= paint.brightnessMin.calculate(parameters);
+ hasTransitions |= paint.brightnessMax.calculate(parameters);
+ hasTransitions |= paint.saturation.calculate(parameters);
+ hasTransitions |= paint.contrast.calculate(parameters);
+ hasTransitions |= paint.fadeDuration.calculate(parameters);
- paints.calculateTransitioned(PropertyKey::RasterOpacity, properties.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::RasterHueRotate, properties.hue_rotate, parameters);
- paints.calculateTransitioned(PropertyKey::RasterBrightnessLow, properties.brightness[0], parameters);
- paints.calculateTransitioned(PropertyKey::RasterBrightnessHigh, properties.brightness[1], parameters);
- paints.calculateTransitioned(PropertyKey::RasterSaturation, properties.saturation, parameters);
- paints.calculateTransitioned(PropertyKey::RasterContrast, properties.contrast, parameters);
- paints.calculateTransitioned(PropertyKey::RasterFade, properties.fade, parameters);
+ passes = paint.opacity > 0 ? RenderPass::Translucent : RenderPass::None;
- passes = properties.isVisible() ? RenderPass::Translucent : RenderPass::None;
+ return hasTransitions;
}
std::unique_ptr<Bucket> RasterLayer::createBucket(StyleBucketParameters&) const {
diff --git a/src/mbgl/layer/raster_layer.hpp b/src/mbgl/layer/raster_layer.hpp
index 650ffc8ef1..800236016d 100644
--- a/src/mbgl/layer/raster_layer.hpp
+++ b/src/mbgl/layer/raster_layer.hpp
@@ -2,11 +2,21 @@
#define MBGL_RASTER_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
+class RasterPaintProperties {
+public:
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<float> hueRotate = 0.0f;
+ PaintProperty<float> brightnessMin = 0.0f;
+ PaintProperty<float> brightnessMax = 1.0f;
+ PaintProperty<float> saturation = 0.0f;
+ PaintProperty<float> contrast = 0.0f;
+ PaintProperty<float> fadeDuration = 0.0f;
+};
+
class RasterLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -15,15 +25,11 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
- PaintPropertiesMap paints;
-
- RasterPaintProperties properties;
+ RasterPaintProperties paint;
};
}
diff --git a/src/mbgl/layer/symbol_layer.cpp b/src/mbgl/layer/symbol_layer.cpp
index 932e500c5e..76c4970deb 100644
--- a/src/mbgl/layer/symbol_layer.cpp
+++ b/src/mbgl/layer/symbol_layer.cpp
@@ -1,8 +1,6 @@
#include <mbgl/layer/symbol_layer.hpp>
#include <mbgl/renderer/symbol_bucket.hpp>
#include <mbgl/map/tile_id.hpp>
-#include <mbgl/style/property_evaluator.hpp>
-#include <mbgl/style/property_parsing.hpp>
#include <mbgl/style/style_bucket_parameters.hpp>
namespace mbgl {
@@ -11,7 +9,7 @@ std::unique_ptr<StyleLayer> SymbolLayer::clone() const {
std::unique_ptr<SymbolLayer> result = std::make_unique<SymbolLayer>();
result->copy(*this);
result->layout = layout;
- result->paints.paints = paints.paints;
+ result->paint = paint;
return std::move(result);
}
@@ -52,71 +50,70 @@ void SymbolLayer::parseLayout(const JSVal& value) {
}
void SymbolLayer::parsePaints(const JSVal& layer) {
- paints.parseEach(layer, [&] (ClassProperties& paint, const JSVal& value) {
- parseProperty<Function<float>>("icon-opacity", PropertyKey::IconOpacity, paint, value);
- parseProperty<PropertyTransition>("icon-opacity-transition", PropertyKey::IconOpacity, paint, value);
- parseProperty<Function<Color>>("icon-color", PropertyKey::IconColor, paint, value);
- parseProperty<PropertyTransition>("icon-color-transition", PropertyKey::IconColor, paint, value);
- parseProperty<Function<Color>>("icon-halo-color", PropertyKey::IconHaloColor, paint, value);
- parseProperty<PropertyTransition>("icon-halo-color-transition", PropertyKey::IconHaloColor, paint, value);
- parseProperty<Function<float>>("icon-halo-width", PropertyKey::IconHaloWidth, paint, value);
- parseProperty<PropertyTransition>("icon-halo-width-transition", PropertyKey::IconHaloWidth, paint, value);
- parseProperty<Function<float>>("icon-halo-blur", PropertyKey::IconHaloBlur, paint, value);
- parseProperty<PropertyTransition>("icon-halo-blur-transition", PropertyKey::IconHaloBlur, paint, value);
- parseProperty<Function<std::array<float, 2>>>("icon-translate", PropertyKey::IconTranslate, paint, value);
- parseProperty<PropertyTransition>("icon-translate-transition", PropertyKey::IconTranslate, paint, value);
- parseProperty<Function<TranslateAnchorType>>("icon-translate-anchor", PropertyKey::IconTranslateAnchor, paint, value);
-
- parseProperty<Function<float>>("text-opacity", PropertyKey::TextOpacity, paint, value);
- parseProperty<PropertyTransition>("text-opacity-transition", PropertyKey::TextOpacity, paint, value);
- parseProperty<Function<Color>>("text-color", PropertyKey::TextColor, paint, value);
- parseProperty<PropertyTransition>("text-color-transition", PropertyKey::TextColor, paint, value);
- parseProperty<Function<Color>>("text-halo-color", PropertyKey::TextHaloColor, paint, value);
- parseProperty<PropertyTransition>("text-halo-color-transition", PropertyKey::TextHaloColor, paint, value);
- parseProperty<Function<float>>("text-halo-width", PropertyKey::TextHaloWidth, paint, value);
- parseProperty<PropertyTransition>("text-halo-width-transition", PropertyKey::TextHaloWidth, paint, value);
- parseProperty<Function<float>>("text-halo-blur", PropertyKey::TextHaloBlur, paint, value);
- parseProperty<PropertyTransition>("text-halo-blur-transition", PropertyKey::TextHaloBlur, paint, value);
- parseProperty<Function<std::array<float, 2>>>("text-translate", PropertyKey::TextTranslate, paint, value);
- parseProperty<PropertyTransition>("text-translate-transition", PropertyKey::TextTranslate, paint, value);
- parseProperty<Function<TranslateAnchorType>>("text-translate-anchor", PropertyKey::TextTranslateAnchor, paint, value);
- });
+ paint.icon.opacity.parse("icon-opacity", layer);
+ paint.icon.color.parse("icon-color", layer);
+ paint.icon.haloColor.parse("icon-halo-color", layer);
+ paint.icon.haloWidth.parse("icon-halo-width", layer);
+ paint.icon.haloBlur.parse("icon-halo-blur", layer);
+ paint.icon.translate.parse("icon-translate", layer);
+ paint.icon.translateAnchor.parse("icon-translate-anchor", layer);
+
+ paint.text.opacity.parse("text-opacity", layer);
+ paint.text.color.parse("text-color", layer);
+ paint.text.haloColor.parse("text-halo-color", layer);
+ paint.text.haloWidth.parse("text-halo-width", layer);
+ paint.text.haloBlur.parse("text-halo-blur", layer);
+ paint.text.translate.parse("text-translate", layer);
+ paint.text.translateAnchor.parse("text-translate-anchor", layer);
}
void SymbolLayer::cascade(const StyleCascadeParameters& parameters) {
- paints.cascade(parameters);
+ paint.icon.opacity.cascade(parameters);
+ paint.icon.color.cascade(parameters);
+ paint.icon.haloColor.cascade(parameters);
+ paint.icon.haloWidth.cascade(parameters);
+ paint.icon.haloBlur.cascade(parameters);
+ paint.icon.translate.cascade(parameters);
+ paint.icon.translateAnchor.cascade(parameters);
+
+ paint.text.opacity.cascade(parameters);
+ paint.text.color.cascade(parameters);
+ paint.text.haloColor.cascade(parameters);
+ paint.text.haloWidth.cascade(parameters);
+ paint.text.haloBlur.cascade(parameters);
+ paint.text.translate.cascade(parameters);
+ paint.text.translateAnchor.cascade(parameters);
}
-bool SymbolLayer::hasTransitions() const {
- return paints.hasTransitions();
-}
-
-void SymbolLayer::recalculate(const StyleCalculationParameters& parameters) {
- paints.removeExpiredTransitions(parameters.now);
-
- paints.calculateTransitioned(PropertyKey::IconOpacity, properties.icon.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::IconColor, properties.icon.color, parameters);
- paints.calculateTransitioned(PropertyKey::IconHaloColor, properties.icon.halo_color, parameters);
- paints.calculateTransitioned(PropertyKey::IconHaloWidth, properties.icon.halo_width, parameters);
- paints.calculateTransitioned(PropertyKey::IconHaloBlur, properties.icon.halo_blur, parameters);
- paints.calculateTransitioned(PropertyKey::IconTranslate, properties.icon.translate, parameters);
- paints.calculate(PropertyKey::IconTranslateAnchor, properties.icon.translate_anchor, parameters);
-
- paints.calculateTransitioned(PropertyKey::TextOpacity, properties.text.opacity, parameters);
- paints.calculateTransitioned(PropertyKey::TextColor, properties.text.color, parameters);
- paints.calculateTransitioned(PropertyKey::TextHaloColor, properties.text.halo_color, parameters);
- paints.calculateTransitioned(PropertyKey::TextHaloWidth, properties.text.halo_width, parameters);
- paints.calculateTransitioned(PropertyKey::TextHaloBlur, properties.text.halo_blur, parameters);
- paints.calculateTransitioned(PropertyKey::TextTranslate, properties.text.translate, parameters);
- paints.calculate(PropertyKey::TextTranslateAnchor, properties.text.translate_anchor, parameters);
+bool SymbolLayer::recalculate(const StyleCalculationParameters& parameters) {
+ bool hasTransitions = false;
+
+ hasTransitions |= paint.icon.opacity.calculate(parameters);
+ hasTransitions |= paint.icon.color.calculate(parameters);
+ hasTransitions |= paint.icon.haloColor.calculate(parameters);
+ hasTransitions |= paint.icon.haloWidth.calculate(parameters);
+ hasTransitions |= paint.icon.haloBlur.calculate(parameters);
+ hasTransitions |= paint.icon.translate.calculate(parameters);
+ hasTransitions |= paint.icon.translateAnchor.calculate(parameters);
+
+ hasTransitions |= paint.text.opacity.calculate(parameters);
+ hasTransitions |= paint.text.color.calculate(parameters);
+ hasTransitions |= paint.text.haloColor.calculate(parameters);
+ hasTransitions |= paint.text.haloWidth.calculate(parameters);
+ hasTransitions |= paint.text.haloBlur.calculate(parameters);
+ hasTransitions |= paint.text.translate.calculate(parameters);
+ hasTransitions |= paint.text.translateAnchor.calculate(parameters);
// text-size and icon-size are layout properties but they also need to be evaluated as paint properties:
layout.icon.size.calculate(parameters);
layout.text.size.calculate(parameters);
- properties.icon.size = layout.icon.size;
- properties.text.size = layout.text.size;
+ paint.icon.size = layout.icon.size;
+ paint.text.size = layout.text.size;
+
+ passes = (paint.icon.isVisible() || paint.text.isVisible())
+ ? RenderPass::Translucent : RenderPass::None;
- passes = properties.isVisible() ? RenderPass::Translucent : RenderPass::None;
+ return hasTransitions;
}
std::unique_ptr<Bucket> SymbolLayer::createBucket(StyleBucketParameters& parameters) const {
diff --git a/src/mbgl/layer/symbol_layer.hpp b/src/mbgl/layer/symbol_layer.hpp
index 3871d7a2d4..9e4555350a 100644
--- a/src/mbgl/layer/symbol_layer.hpp
+++ b/src/mbgl/layer/symbol_layer.hpp
@@ -2,9 +2,8 @@
#define MBGL_SYMBOL_LAYER
#include <mbgl/style/style_layer.hpp>
-#include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/paint_properties_map.hpp>
#include <mbgl/style/layout_property.hpp>
+#include <mbgl/style/paint_property.hpp>
namespace mbgl {
@@ -55,6 +54,32 @@ public:
float textMaxSize = 16.0f;
};
+class SymbolPaintProperties {
+public:
+ class PaintProperties {
+ public:
+ PaintProperties(float size_) : size(size_) {}
+
+ PaintProperty<float> opacity = 1.0f;
+ PaintProperty<Color> color = { {{ 0, 0, 0, 1 }} };
+ PaintProperty<Color> haloColor = { {{ 0, 0, 0, 0 }} };
+ PaintProperty<float> haloWidth = 0.0f;
+ PaintProperty<float> haloBlur = 0.0f;
+ PaintProperty<std::array<float, 2>> translate = { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> translateAnchor = TranslateAnchorType::Map;
+
+ // Special case
+ float size;
+
+ bool isVisible() const {
+ return opacity > 0 && (color.value[3] > 0 || haloColor.value[3] > 0) && size > 0;
+ }
+ };
+
+ PaintProperties icon { 1.0f };
+ PaintProperties text { 16.0f };
+};
+
class SymbolLayer : public StyleLayer {
public:
std::unique_ptr<StyleLayer> clone() const override;
@@ -63,16 +88,12 @@ public:
void parsePaints(const JSVal&) override;
void cascade(const StyleCascadeParameters&) override;
- void recalculate(const StyleCalculationParameters&) override;
+ bool recalculate(const StyleCalculationParameters&) override;
std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override;
- bool hasTransitions() const override;
-
SymbolLayoutProperties layout;
- PaintPropertiesMap paints;
-
- SymbolPaintProperties properties;
+ SymbolPaintProperties paint;
};
}
View Lorry Controller Status