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.cpp20
-rw-r--r--src/mbgl/layer/background_layer.hpp6
-rw-r--r--src/mbgl/layer/circle_layer.cpp36
-rw-r--r--src/mbgl/layer/circle_layer.hpp14
-rw-r--r--src/mbgl/layer/fill_layer.cpp46
-rw-r--r--src/mbgl/layer/fill_layer.hpp14
-rw-r--r--src/mbgl/layer/line_layer.cpp80
-rw-r--r--src/mbgl/layer/line_layer.hpp30
-rw-r--r--src/mbgl/layer/raster_layer.cpp44
-rw-r--r--src/mbgl/layer/raster_layer.hpp14
-rw-r--r--src/mbgl/layer/symbol_layer.cpp249
-rw-r--r--src/mbgl/layer/symbol_layer.hpp118
12 files changed, 333 insertions, 338 deletions
diff --git a/src/mbgl/layer/background_layer.cpp b/src/mbgl/layer/background_layer.cpp
index 25fbe620e5..e2879f786e 100644
--- a/src/mbgl/layer/background_layer.cpp
+++ b/src/mbgl/layer/background_layer.cpp
@@ -8,25 +8,25 @@ std::unique_ptr<StyleLayer> BackgroundLayer::clone() const {
}
void BackgroundLayer::parsePaints(const JSValue& layer) {
- paint.opacity.parse("background-opacity", layer);
- paint.color.parse("background-color", layer);
- paint.pattern.parse("background-pattern", layer);
+ paint.backgroundOpacity.parse("background-opacity", layer);
+ paint.backgroundColor.parse("background-color", layer);
+ paint.backgroundPattern.parse("background-pattern", layer);
}
void BackgroundLayer::cascade(const StyleCascadeParameters& parameters) {
- paint.opacity.cascade(parameters);
- paint.color.cascade(parameters);
- paint.pattern.cascade(parameters);
+ paint.backgroundOpacity.cascade(parameters);
+ paint.backgroundColor.cascade(parameters);
+ paint.backgroundPattern.cascade(parameters);
}
bool BackgroundLayer::recalculate(const StyleCalculationParameters& parameters) {
bool hasTransitions = false;
- hasTransitions |= paint.opacity.calculate(parameters);
- hasTransitions |= paint.color.calculate(parameters);
- hasTransitions |= paint.pattern.calculate(parameters);
+ hasTransitions |= paint.backgroundOpacity.calculate(parameters);
+ hasTransitions |= paint.backgroundColor.calculate(parameters);
+ hasTransitions |= paint.backgroundPattern.calculate(parameters);
- passes = paint.opacity > 0 ? RenderPass::Translucent : RenderPass::None;
+ passes = paint.backgroundOpacity > 0 ? RenderPass::Translucent : RenderPass::None;
return hasTransitions;
}
diff --git a/src/mbgl/layer/background_layer.hpp b/src/mbgl/layer/background_layer.hpp
index 118bb19053..786dd0732f 100644
--- a/src/mbgl/layer/background_layer.hpp
+++ b/src/mbgl/layer/background_layer.hpp
@@ -8,9 +8,9 @@ namespace mbgl {
class BackgroundPaintProperties {
public:
- PaintProperty<float> opacity { 1.0f };
- PaintProperty<Color> color { {{ 0, 0, 0, 1 }} };
- PaintProperty<std::string, Faded<std::string>> pattern { "" };
+ PaintProperty<float> backgroundOpacity { 1.0f };
+ PaintProperty<Color> backgroundColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<std::string, Faded<std::string>> backgroundPattern { "" };
};
class BackgroundLayer : public StyleLayer {
diff --git a/src/mbgl/layer/circle_layer.cpp b/src/mbgl/layer/circle_layer.cpp
index b668847f55..bd70e1649e 100644
--- a/src/mbgl/layer/circle_layer.cpp
+++ b/src/mbgl/layer/circle_layer.cpp
@@ -10,32 +10,32 @@ std::unique_ptr<StyleLayer> CircleLayer::clone() const {
}
void CircleLayer::parsePaints(const JSValue& layer) {
- 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);
+ paint.circleRadius.parse("circle-radius", layer);
+ paint.circleColor.parse("circle-color", layer);
+ paint.circleOpacity.parse("circle-opacity", layer);
+ paint.circleTranslate.parse("circle-translate", layer);
+ paint.circleTranslateAnchor.parse("circle-translate-anchor", layer);
+ paint.circleBlur.parse("circle-blur", layer);
}
void CircleLayer::cascade(const StyleCascadeParameters& 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);
+ paint.circleRadius.cascade(parameters);
+ paint.circleColor.cascade(parameters);
+ paint.circleOpacity.cascade(parameters);
+ paint.circleTranslate.cascade(parameters);
+ paint.circleTranslateAnchor.cascade(parameters);
+ paint.circleBlur.cascade(parameters);
}
bool CircleLayer::recalculate(const StyleCalculationParameters& parameters) {
bool hasTransitions = false;
- 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);
+ hasTransitions |= paint.circleRadius.calculate(parameters);
+ hasTransitions |= paint.circleColor.calculate(parameters);
+ hasTransitions |= paint.circleOpacity.calculate(parameters);
+ hasTransitions |= paint.circleTranslate.calculate(parameters);
+ hasTransitions |= paint.circleTranslateAnchor.calculate(parameters);
+ hasTransitions |= paint.circleBlur.calculate(parameters);
passes = paint.isVisible() ? RenderPass::Translucent : RenderPass::None;
diff --git a/src/mbgl/layer/circle_layer.hpp b/src/mbgl/layer/circle_layer.hpp
index 036bf79991..2eda3e783a 100644
--- a/src/mbgl/layer/circle_layer.hpp
+++ b/src/mbgl/layer/circle_layer.hpp
@@ -8,15 +8,15 @@ 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 };
+ PaintProperty<float> circleRadius { 5.0f };
+ PaintProperty<Color> circleColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<float> circleOpacity { 1.0f };
+ PaintProperty<std::array<float, 2>> circleTranslate { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> circleTranslateAnchor { TranslateAnchorType::Map };
+ PaintProperty<float> circleBlur { 0 };
bool isVisible() const {
- return radius > 0 && color.value[3] > 0 && opacity > 0;
+ return circleRadius > 0 && circleColor.value[3] > 0 && circleOpacity > 0;
}
};
diff --git a/src/mbgl/layer/fill_layer.cpp b/src/mbgl/layer/fill_layer.cpp
index 739a6fd20c..0ba83e7fe4 100644
--- a/src/mbgl/layer/fill_layer.cpp
+++ b/src/mbgl/layer/fill_layer.cpp
@@ -10,43 +10,43 @@ std::unique_ptr<StyleLayer> FillLayer::clone() const {
}
void FillLayer::parsePaints(const JSValue& layer) {
- 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);
+ paint.fillAntialias.parse("fill-antialias", layer);
+ paint.fillOpacity.parse("fill-opacity", layer);
+ paint.fillColor.parse("fill-color", layer);
+ paint.fillOutlineColor.parse("fill-outline-color", layer);
+ paint.fillTranslate.parse("fill-translate", layer);
+ paint.fillTranslateAnchor.parse("fill-translate-anchor", layer);
+ paint.fillPattern.parse("fill-pattern", layer);
}
void FillLayer::cascade(const StyleCascadeParameters& parameters) {
- 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);
+ paint.fillAntialias.cascade(parameters);
+ paint.fillOpacity.cascade(parameters);
+ paint.fillColor.cascade(parameters);
+ paint.fillOutlineColor.cascade(parameters);
+ paint.fillTranslate.cascade(parameters);
+ paint.fillTranslateAnchor.cascade(parameters);
+ paint.fillPattern.cascade(parameters);
}
bool FillLayer::recalculate(const StyleCalculationParameters& parameters) {
bool hasTransitions = false;
- 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);
+ hasTransitions |= paint.fillAntialias.calculate(parameters);
+ hasTransitions |= paint.fillOpacity.calculate(parameters);
+ hasTransitions |= paint.fillColor.calculate(parameters);
+ hasTransitions |= paint.fillOutlineColor.calculate(parameters);
+ hasTransitions |= paint.fillTranslate.calculate(parameters);
+ hasTransitions |= paint.fillTranslateAnchor.calculate(parameters);
+ hasTransitions |= paint.fillPattern.calculate(parameters);
passes = RenderPass::None;
- if (paint.antialias) {
+ if (paint.fillAntialias) {
passes |= RenderPass::Translucent;
}
- if (!paint.pattern.value.from.empty() || (paint.color.value[3] * paint.opacity) < 1.0f) {
+ if (!paint.fillPattern.value.from.empty() || (paint.fillColor.value[3] * paint.fillOpacity) < 1.0f) {
passes |= RenderPass::Translucent;
} else {
passes |= RenderPass::Opaque;
diff --git a/src/mbgl/layer/fill_layer.hpp b/src/mbgl/layer/fill_layer.hpp
index 3b1c5a84fe..3a6f1fbf19 100644
--- a/src/mbgl/layer/fill_layer.hpp
+++ b/src/mbgl/layer/fill_layer.hpp
@@ -8,13 +8,13 @@ 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 { "" };
+ PaintProperty<bool> fillAntialias { true };
+ PaintProperty<float> fillOpacity { 1.0f };
+ PaintProperty<Color> fillColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<Color> fillOutlineColor { {{ 0, 0, 0, -1 }} };
+ PaintProperty<std::array<float, 2>> fillTranslate { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> fillTranslateAnchor { TranslateAnchorType::Map };
+ PaintProperty<std::string, Faded<std::string>> fillPattern { "" };
};
class FillLayer : public StyleLayer {
diff --git a/src/mbgl/layer/line_layer.cpp b/src/mbgl/layer/line_layer.cpp
index c3576a9ee2..83994edf6c 100644
--- a/src/mbgl/layer/line_layer.cpp
+++ b/src/mbgl/layer/line_layer.cpp
@@ -11,57 +11,57 @@ std::unique_ptr<StyleLayer> LineLayer::clone() const {
}
void LineLayer::parseLayout(const JSValue& value) {
- layout.cap.parse("line-cap", value);
- layout.join.parse("line-join", value);
- layout.miterLimit.parse("line-miter-limit", value);
- layout.roundLimit.parse("line-round-limit", value);
+ layout.lineCap.parse("line-cap", value);
+ layout.lineJoin.parse("line-join", value);
+ layout.lineMiterLimit.parse("line-miter-limit", value);
+ layout.lineRoundLimit.parse("line-round-limit", value);
}
void LineLayer::parsePaints(const JSValue& layer) {
- 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.offset.parse("line-offset", layer);
- paint.blur.parse("line-blur", layer);
- paint.dasharray.parse("line-dasharray", layer);
- paint.pattern.parse("line-pattern", layer);
+ paint.lineOpacity.parse("line-opacity", layer);
+ paint.lineColor.parse("line-color", layer);
+ paint.lineTranslate.parse("line-translate", layer);
+ paint.lineTranslateAnchor.parse("line-translate-anchor", layer);
+ paint.lineWidth.parse("line-width", layer);
+ paint.lineGapWidth.parse("line-gap-width", layer);
+ paint.lineOffset.parse("line-offset", layer);
+ paint.lineBlur.parse("line-blur", layer);
+ paint.lineDasharray.parse("line-dasharray", layer);
+ paint.linePattern.parse("line-pattern", layer);
}
void LineLayer::cascade(const StyleCascadeParameters& parameters) {
- 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.offset.cascade(parameters);
- paint.blur.cascade(parameters);
- paint.dasharray.cascade(parameters);
- paint.pattern.cascade(parameters);
+ paint.lineOpacity.cascade(parameters);
+ paint.lineColor.cascade(parameters);
+ paint.lineTranslate.cascade(parameters);
+ paint.lineTranslateAnchor.cascade(parameters);
+ paint.lineWidth.cascade(parameters);
+ paint.lineGapWidth.cascade(parameters);
+ paint.lineOffset.cascade(parameters);
+ paint.lineBlur.cascade(parameters);
+ paint.lineDasharray.cascade(parameters);
+ paint.linePattern.cascade(parameters);
}
bool LineLayer::recalculate(const StyleCalculationParameters& parameters) {
// for scaling dasharrays
StyleCalculationParameters dashArrayParams = parameters;
dashArrayParams.z = std::floor(dashArrayParams.z);
- paint.width.calculate(dashArrayParams);
- paint.dashLineWidth = paint.width;
+ paint.lineWidth.calculate(dashArrayParams);
+ paint.dashLineWidth = paint.lineWidth;
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.offset.calculate(parameters);
- hasTransitions |= paint.blur.calculate(parameters);
- hasTransitions |= paint.dasharray.calculate(parameters);
- hasTransitions |= paint.pattern.calculate(parameters);
+ hasTransitions |= paint.lineOpacity.calculate(parameters);
+ hasTransitions |= paint.lineColor.calculate(parameters);
+ hasTransitions |= paint.lineTranslate.calculate(parameters);
+ hasTransitions |= paint.lineTranslateAnchor.calculate(parameters);
+ hasTransitions |= paint.lineWidth.calculate(parameters);
+ hasTransitions |= paint.lineGapWidth.calculate(parameters);
+ hasTransitions |= paint.lineOffset.calculate(parameters);
+ hasTransitions |= paint.lineBlur.calculate(parameters);
+ hasTransitions |= paint.lineDasharray.calculate(parameters);
+ hasTransitions |= paint.linePattern.calculate(parameters);
passes = paint.isVisible() ? RenderPass::Translucent : RenderPass::None;
@@ -74,10 +74,10 @@ std::unique_ptr<Bucket> LineLayer::createBucket(StyleBucketParameters& parameter
bucket->layout = layout;
StyleCalculationParameters p(parameters.tileID.z);
- bucket->layout.cap.calculate(p);
- bucket->layout.join.calculate(p);
- bucket->layout.miterLimit.calculate(p);
- bucket->layout.roundLimit.calculate(p);
+ bucket->layout.lineCap.calculate(p);
+ bucket->layout.lineJoin.calculate(p);
+ bucket->layout.lineMiterLimit.calculate(p);
+ bucket->layout.lineRoundLimit.calculate(p);
parameters.eachFilteredFeature(filter, [&] (const auto& feature) {
bucket->addGeometry(getGeometries(feature));
diff --git a/src/mbgl/layer/line_layer.hpp b/src/mbgl/layer/line_layer.hpp
index f7f5abdbfc..fba8050774 100644
--- a/src/mbgl/layer/line_layer.hpp
+++ b/src/mbgl/layer/line_layer.hpp
@@ -9,30 +9,30 @@ namespace mbgl {
class LineLayoutProperties {
public:
- LayoutProperty<LineCapType> cap { LineCapType::Butt };
- LayoutProperty<LineJoinType> join { LineJoinType::Miter };
- LayoutProperty<float> miterLimit { 2.0f };
- LayoutProperty<float> roundLimit { 1.0f };
+ LayoutProperty<LineCapType> lineCap { LineCapType::Butt };
+ LayoutProperty<LineJoinType> lineJoin { LineJoinType::Miter };
+ LayoutProperty<float> lineMiterLimit { 2.0f };
+ LayoutProperty<float> lineRoundLimit { 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<float> offset { 0 };
- PaintProperty<std::vector<float>, Faded<std::vector<float>>> dasharray { {} };
- PaintProperty<std::string, Faded<std::string>> pattern { "" };
+ PaintProperty<float> lineOpacity { 1.0f };
+ PaintProperty<Color> lineColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<std::array<float, 2>> lineTranslate { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> lineTranslateAnchor { TranslateAnchorType::Map };
+ PaintProperty<float> lineWidth { 1 };
+ PaintProperty<float> lineGapWidth { 0 };
+ PaintProperty<float> lineBlur { 0 };
+ PaintProperty<float> lineOffset { 0 };
+ PaintProperty<std::vector<float>, Faded<std::vector<float>>> lineDasharray { {} };
+ PaintProperty<std::string, Faded<std::string>> linePattern { "" };
// Special case
float dashLineWidth = 1;
bool isVisible() const {
- return opacity > 0 && color.value[3] > 0 && width > 0;
+ return lineOpacity > 0 && lineColor.value[3] > 0 && lineWidth > 0;
}
};
diff --git a/src/mbgl/layer/raster_layer.cpp b/src/mbgl/layer/raster_layer.cpp
index 401097073d..fa41609039 100644
--- a/src/mbgl/layer/raster_layer.cpp
+++ b/src/mbgl/layer/raster_layer.cpp
@@ -8,37 +8,37 @@ std::unique_ptr<StyleLayer> RasterLayer::clone() const {
}
void RasterLayer::parsePaints(const JSValue& layer) {
- 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);
+ paint.rasterOpacity.parse("raster-opacity", layer);
+ paint.rasterHueRotate.parse("raster-hue-rotate", layer);
+ paint.rasterBrightnessMin.parse("raster-brightness-min", layer);
+ paint.rasterBrightnessMax.parse("raster-brightness-max", layer);
+ paint.rasterSaturation.parse("raster-saturation", layer);
+ paint.rasterContrast.parse("raster-contrast", layer);
+ paint.rasterFadeDuration.parse("raster-fade-duration", layer);
}
void RasterLayer::cascade(const StyleCascadeParameters& 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);
+ paint.rasterOpacity.cascade(parameters);
+ paint.rasterHueRotate.cascade(parameters);
+ paint.rasterBrightnessMin.cascade(parameters);
+ paint.rasterBrightnessMax.cascade(parameters);
+ paint.rasterSaturation.cascade(parameters);
+ paint.rasterContrast.cascade(parameters);
+ paint.rasterFadeDuration.cascade(parameters);
}
bool RasterLayer::recalculate(const StyleCalculationParameters& parameters) {
bool hasTransitions = false;
- 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);
+ hasTransitions |= paint.rasterOpacity.calculate(parameters);
+ hasTransitions |= paint.rasterHueRotate.calculate(parameters);
+ hasTransitions |= paint.rasterBrightnessMin.calculate(parameters);
+ hasTransitions |= paint.rasterBrightnessMax.calculate(parameters);
+ hasTransitions |= paint.rasterSaturation.calculate(parameters);
+ hasTransitions |= paint.rasterContrast.calculate(parameters);
+ hasTransitions |= paint.rasterFadeDuration.calculate(parameters);
- passes = paint.opacity > 0 ? RenderPass::Translucent : RenderPass::None;
+ passes = paint.rasterOpacity > 0 ? RenderPass::Translucent : RenderPass::None;
return hasTransitions;
}
diff --git a/src/mbgl/layer/raster_layer.hpp b/src/mbgl/layer/raster_layer.hpp
index 52c0f0a7ae..1acf8f5685 100644
--- a/src/mbgl/layer/raster_layer.hpp
+++ b/src/mbgl/layer/raster_layer.hpp
@@ -8,13 +8,13 @@ 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 };
+ PaintProperty<float> rasterOpacity { 1.0f };
+ PaintProperty<float> rasterHueRotate { 0.0f };
+ PaintProperty<float> rasterBrightnessMin { 0.0f };
+ PaintProperty<float> rasterBrightnessMax { 1.0f };
+ PaintProperty<float> rasterSaturation { 0.0f };
+ PaintProperty<float> rasterContrast { 0.0f };
+ PaintProperty<float> rasterFadeDuration { 0.0f };
};
class RasterLayer : public StyleLayer {
diff --git a/src/mbgl/layer/symbol_layer.cpp b/src/mbgl/layer/symbol_layer.cpp
index 477d28b6e0..6b02fc6d2b 100644
--- a/src/mbgl/layer/symbol_layer.cpp
+++ b/src/mbgl/layer/symbol_layer.cpp
@@ -10,104 +10,103 @@ std::unique_ptr<StyleLayer> SymbolLayer::clone() const {
}
void SymbolLayer::parseLayout(const JSValue& value) {
- layout.placement.parse("symbol-placement", value);
- layout.spacing.parse("symbol-spacing", value);
- layout.avoidEdges.parse("symbol-avoid-edges", value);
-
- layout.icon.allowOverlap.parse("icon-allow-overlap", value);
- layout.icon.ignorePlacement.parse("icon-ignore-placement", value);
- layout.icon.optional.parse("icon-optional", value);
- layout.icon.rotationAlignment.parse("icon-rotation-alignment", value);
- layout.icon.size.parse("icon-size", value);
- layout.icon.image.parse("icon-image", value);
- layout.icon.rotate.parse("icon-rotate", value);
- layout.icon.padding.parse("icon-padding", value);
- layout.icon.keepUpright.parse("icon-keep-upright", value);
- layout.icon.offset.parse("icon-offset", value);
-
- layout.text.rotationAlignment.parse("text-rotation-alignment", value);
- layout.text.field.parse("text-field", value);
- layout.text.font.parse("text-font", value);
- layout.text.size.parse("text-size", value);
- layout.text.maxWidth.parse("text-max-width", value);
- layout.text.lineHeight.parse("text-line-height", value);
- layout.text.letterSpacing.parse("text-letter-spacing", value);
- layout.text.justify.parse("text-justify", value);
- layout.text.anchor.parse("text-anchor", value);
- layout.text.maxAngle.parse("text-max-angle", value);
- layout.text.rotate.parse("text-rotate", value);
- layout.text.padding.parse("text-padding", value);
- layout.text.keepUpright.parse("text-keep-upright", value);
- layout.text.transform.parse("text-transform", value);
- layout.text.offset.parse("text-offset", value);
- layout.text.allowOverlap.parse("text-allow-overlap", value);
- layout.text.ignorePlacement.parse("text-ignore-placement", value);
- layout.text.optional.parse("text-optional", value);
+ layout.symbolPlacement.parse("symbol-placement", value);
+ layout.symbolSpacing.parse("symbol-spacing", value);
+ layout.symbolAvoidEdges.parse("symbol-avoid-edges", value);
+
+ layout.iconAllowOverlap.parse("icon-allow-overlap", value);
+ layout.iconIgnorePlacement.parse("icon-ignore-placement", value);
+ layout.iconOptional.parse("icon-optional", value);
+ layout.iconRotationAlignment.parse("icon-rotation-alignment", value);
+ layout.iconSize.parse("icon-size", value);
+ layout.iconImage.parse("icon-image", value);
+ layout.iconRotate.parse("icon-rotate", value);
+ layout.iconPadding.parse("icon-padding", value);
+ layout.iconKeepUpright.parse("icon-keep-upright", value);
+ layout.iconOffset.parse("icon-offset", value);
+
+ layout.textRotationAlignment.parse("text-rotation-alignment", value);
+ layout.textField.parse("text-field", value);
+ layout.textFont.parse("text-font", value);
+ layout.textSize.parse("text-size", value);
+ layout.textMaxWidth.parse("text-max-width", value);
+ layout.textLineHeight.parse("text-line-height", value);
+ layout.textLetterSpacing.parse("text-letter-spacing", value);
+ layout.textJustify.parse("text-justify", value);
+ layout.textAnchor.parse("text-anchor", value);
+ layout.textMaxAngle.parse("text-max-angle", value);
+ layout.textRotate.parse("text-rotate", value);
+ layout.textPadding.parse("text-padding", value);
+ layout.textKeepUpright.parse("text-keep-upright", value);
+ layout.textTransform.parse("text-transform", value);
+ layout.textOffset.parse("text-offset", value);
+ layout.textAllowOverlap.parse("text-allow-overlap", value);
+ layout.textIgnorePlacement.parse("text-ignore-placement", value);
+ layout.textOptional.parse("text-optional", value);
}
void SymbolLayer::parsePaints(const JSValue& layer) {
- 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);
+ paint.iconOpacity.parse("icon-opacity", layer);
+ paint.iconColor.parse("icon-color", layer);
+ paint.iconHaloColor.parse("icon-halo-color", layer);
+ paint.iconHaloWidth.parse("icon-halo-width", layer);
+ paint.iconHaloBlur.parse("icon-halo-blur", layer);
+ paint.iconTranslate.parse("icon-translate", layer);
+ paint.iconTranslateAnchor.parse("icon-translate-anchor", layer);
+
+ paint.textOpacity.parse("text-opacity", layer);
+ paint.textColor.parse("text-color", layer);
+ paint.textHaloColor.parse("text-halo-color", layer);
+ paint.textHaloWidth.parse("text-halo-width", layer);
+ paint.textHaloBlur.parse("text-halo-blur", layer);
+ paint.textTranslate.parse("text-translate", layer);
+ paint.textTranslateAnchor.parse("text-translate-anchor", layer);
}
void SymbolLayer::cascade(const StyleCascadeParameters& 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);
+ paint.iconOpacity.cascade(parameters);
+ paint.iconColor.cascade(parameters);
+ paint.iconHaloColor.cascade(parameters);
+ paint.iconHaloWidth.cascade(parameters);
+ paint.iconHaloBlur.cascade(parameters);
+ paint.iconTranslate.cascade(parameters);
+ paint.iconTranslateAnchor.cascade(parameters);
+
+ paint.textOpacity.cascade(parameters);
+ paint.textColor.cascade(parameters);
+ paint.textHaloColor.cascade(parameters);
+ paint.textHaloWidth.cascade(parameters);
+ paint.textHaloBlur.cascade(parameters);
+ paint.textTranslate.cascade(parameters);
+ paint.textTranslateAnchor.cascade(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);
+ hasTransitions |= paint.iconOpacity.calculate(parameters);
+ hasTransitions |= paint.iconColor.calculate(parameters);
+ hasTransitions |= paint.iconHaloColor.calculate(parameters);
+ hasTransitions |= paint.iconHaloWidth.calculate(parameters);
+ hasTransitions |= paint.iconHaloBlur.calculate(parameters);
+ hasTransitions |= paint.iconTranslate.calculate(parameters);
+ hasTransitions |= paint.iconTranslateAnchor.calculate(parameters);
+
+ hasTransitions |= paint.textOpacity.calculate(parameters);
+ hasTransitions |= paint.textColor.calculate(parameters);
+ hasTransitions |= paint.textHaloColor.calculate(parameters);
+ hasTransitions |= paint.textHaloWidth.calculate(parameters);
+ hasTransitions |= paint.textHaloBlur.calculate(parameters);
+ hasTransitions |= paint.textTranslate.calculate(parameters);
+ hasTransitions |= paint.textTranslateAnchor.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);
- paint.icon.size = layout.icon.size;
- paint.text.size = layout.text.size;
+ layout.iconSize.calculate(parameters);
+ layout.textSize.calculate(parameters);
+ paint.iconSize = layout.iconSize;
+ paint.textSize = layout.textSize;
- passes = (paint.icon.isVisible() || paint.text.isVisible())
- ? RenderPass::Translucent : RenderPass::None;
+ passes = paint.isVisible() ? RenderPass::Translucent : RenderPass::None;
return hasTransitions;
}
@@ -120,48 +119,48 @@ std::unique_ptr<Bucket> SymbolLayer::createBucket(StyleBucketParameters& paramet
bucket->layout = layout;
StyleCalculationParameters p(parameters.tileID.z);
- bucket->layout.placement.calculate(p);
- if (bucket->layout.placement.value == SymbolPlacementType::Line) {
- bucket->layout.icon.rotationAlignment.value = RotationAlignmentType::Map;
- bucket->layout.text.rotationAlignment.value = RotationAlignmentType::Map;
+ bucket->layout.symbolPlacement.calculate(p);
+ if (bucket->layout.symbolPlacement.value == SymbolPlacementType::Line) {
+ bucket->layout.iconRotationAlignment.value = RotationAlignmentType::Map;
+ bucket->layout.textRotationAlignment.value = RotationAlignmentType::Map;
};
- bucket->layout.spacing.calculate(p);
- bucket->layout.avoidEdges.calculate(p);
-
- bucket->layout.icon.allowOverlap.calculate(p);
- bucket->layout.icon.ignorePlacement.calculate(p);
- bucket->layout.icon.optional.calculate(p);
- bucket->layout.icon.rotationAlignment.calculate(p);
- bucket->layout.icon.image.calculate(p);
- bucket->layout.icon.padding.calculate(p);
- bucket->layout.icon.rotate.calculate(p);
- bucket->layout.icon.keepUpright.calculate(p);
- bucket->layout.icon.offset.calculate(p);
-
- bucket->layout.text.rotationAlignment.calculate(p);
- bucket->layout.text.field.calculate(p);
- bucket->layout.text.font.calculate(p);
- bucket->layout.text.maxWidth.calculate(p);
- bucket->layout.text.lineHeight.calculate(p);
- bucket->layout.text.letterSpacing.calculate(p);
- bucket->layout.text.maxAngle.calculate(p);
- bucket->layout.text.rotate.calculate(p);
- bucket->layout.text.padding.calculate(p);
- bucket->layout.text.ignorePlacement.calculate(p);
- bucket->layout.text.optional.calculate(p);
- bucket->layout.text.justify.calculate(p);
- bucket->layout.text.anchor.calculate(p);
- bucket->layout.text.keepUpright.calculate(p);
- bucket->layout.text.transform.calculate(p);
- bucket->layout.text.offset.calculate(p);
- bucket->layout.text.allowOverlap.calculate(p);
-
- bucket->layout.icon.size.calculate(StyleCalculationParameters(18));
- bucket->layout.text.size.calculate(StyleCalculationParameters(18));
- bucket->layout.iconMaxSize = bucket->layout.icon.size;
- bucket->layout.textMaxSize = bucket->layout.text.size;
- bucket->layout.icon.size.calculate(StyleCalculationParameters(p.z + 1));
- bucket->layout.text.size.calculate(StyleCalculationParameters(p.z + 1));
+ bucket->layout.symbolSpacing.calculate(p);
+ bucket->layout.symbolAvoidEdges.calculate(p);
+
+ bucket->layout.iconAllowOverlap.calculate(p);
+ bucket->layout.iconIgnorePlacement.calculate(p);
+ bucket->layout.iconOptional.calculate(p);
+ bucket->layout.iconRotationAlignment.calculate(p);
+ bucket->layout.iconImage.calculate(p);
+ bucket->layout.iconPadding.calculate(p);
+ bucket->layout.iconRotate.calculate(p);
+ bucket->layout.iconKeepUpright.calculate(p);
+ bucket->layout.iconOffset.calculate(p);
+
+ bucket->layout.textRotationAlignment.calculate(p);
+ bucket->layout.textField.calculate(p);
+ bucket->layout.textFont.calculate(p);
+ bucket->layout.textMaxWidth.calculate(p);
+ bucket->layout.textLineHeight.calculate(p);
+ bucket->layout.textLetterSpacing.calculate(p);
+ bucket->layout.textMaxAngle.calculate(p);
+ bucket->layout.textRotate.calculate(p);
+ bucket->layout.textPadding.calculate(p);
+ bucket->layout.textIgnorePlacement.calculate(p);
+ bucket->layout.textOptional.calculate(p);
+ bucket->layout.textJustify.calculate(p);
+ bucket->layout.textAnchor.calculate(p);
+ bucket->layout.textKeepUpright.calculate(p);
+ bucket->layout.textTransform.calculate(p);
+ bucket->layout.textOffset.calculate(p);
+ bucket->layout.textAllowOverlap.calculate(p);
+
+ bucket->layout.iconSize.calculate(StyleCalculationParameters(18));
+ bucket->layout.textSize.calculate(StyleCalculationParameters(18));
+ bucket->layout.iconMaxSize = bucket->layout.iconSize;
+ bucket->layout.textMaxSize = bucket->layout.textSize;
+ bucket->layout.iconSize.calculate(StyleCalculationParameters(p.z + 1));
+ bucket->layout.textSize.calculate(StyleCalculationParameters(p.z + 1));
bucket->parseFeatures(parameters.layer, filter);
diff --git a/src/mbgl/layer/symbol_layer.hpp b/src/mbgl/layer/symbol_layer.hpp
index 75759e2a19..95d71bb3cb 100644
--- a/src/mbgl/layer/symbol_layer.hpp
+++ b/src/mbgl/layer/symbol_layer.hpp
@@ -11,45 +11,39 @@ class SpriteAtlas;
class SymbolLayoutProperties {
public:
- LayoutProperty<SymbolPlacementType> placement { SymbolPlacementType::Point };
- LayoutProperty<float> spacing { 250.0f };
- LayoutProperty<bool> avoidEdges { false };
-
- class IconProperties {
- public:
- LayoutProperty<bool> allowOverlap { false };
- LayoutProperty<bool> ignorePlacement { false };
- LayoutProperty<bool> optional { false };
- LayoutProperty<RotationAlignmentType> rotationAlignment { RotationAlignmentType::Viewport };
- LayoutProperty<float> size { 1.0f };
- LayoutProperty<std::string> image { "" };
- LayoutProperty<float> rotate { 0.0f };
- LayoutProperty<float> padding { 2.0f };
- LayoutProperty<bool> keepUpright { false };
- LayoutProperty<std::array<float, 2>> offset { {{ 0, 0 }} };
- } icon;
-
- class TextProperties {
- public:
- LayoutProperty<RotationAlignmentType> rotationAlignment { RotationAlignmentType::Viewport };
- LayoutProperty<std::string> field { "" };
- LayoutProperty<std::string> font { "Open Sans Regular, Arial Unicode MS Regular" };
- LayoutProperty<float> size { 16.0f };
- LayoutProperty<float> maxWidth { 15.0f /* em */ };
- LayoutProperty<float> lineHeight { 1.2f /* em */ };
- LayoutProperty<float> letterSpacing { 0.0f /* em */ };
- LayoutProperty<TextJustifyType> justify { TextJustifyType::Center };
- LayoutProperty<TextAnchorType> anchor { TextAnchorType::Center };
- LayoutProperty<float> maxAngle { 45.0f /* degrees */ };
- LayoutProperty<float> rotate { 0.0f };
- LayoutProperty<float> padding { 2.0f };
- LayoutProperty<bool> keepUpright { true };
- LayoutProperty<TextTransformType> transform { TextTransformType::None };
- LayoutProperty<std::array<float, 2>> offset { {{ 0, 0 }} };
- LayoutProperty<bool> allowOverlap { false };
- LayoutProperty<bool> ignorePlacement { false };
- LayoutProperty<bool> optional { false };
- } text;
+ LayoutProperty<SymbolPlacementType> symbolPlacement { SymbolPlacementType::Point };
+ LayoutProperty<float> symbolSpacing { 250.0f };
+ LayoutProperty<bool> symbolAvoidEdges { false };
+
+ LayoutProperty<bool> iconAllowOverlap { false };
+ LayoutProperty<bool> iconIgnorePlacement { false };
+ LayoutProperty<bool> iconOptional { false };
+ LayoutProperty<RotationAlignmentType> iconRotationAlignment { RotationAlignmentType::Viewport };
+ LayoutProperty<float> iconSize { 1.0f };
+ LayoutProperty<std::string> iconImage { "" };
+ LayoutProperty<float> iconRotate { 0.0f };
+ LayoutProperty<float> iconPadding { 2.0f };
+ LayoutProperty<bool> iconKeepUpright { false };
+ LayoutProperty<std::array<float, 2>> iconOffset { {{ 0, 0 }} };
+
+ LayoutProperty<RotationAlignmentType> textRotationAlignment { RotationAlignmentType::Viewport };
+ LayoutProperty<std::string> textField { "" };
+ LayoutProperty<std::string> textFont { "Open Sans Regular, Arial Unicode MS Regular" };
+ LayoutProperty<float> textSize { 16.0f };
+ LayoutProperty<float> textMaxWidth { 15.0f /* em */ };
+ LayoutProperty<float> textLineHeight { 1.2f /* em */ };
+ LayoutProperty<float> textLetterSpacing { 0.0f /* em */ };
+ LayoutProperty<TextJustifyType> textJustify { TextJustifyType::Center };
+ LayoutProperty<TextAnchorType> textAnchor { TextAnchorType::Center };
+ LayoutProperty<float> textMaxAngle { 45.0f /* degrees */ };
+ LayoutProperty<float> textRotate { 0.0f };
+ LayoutProperty<float> textPadding { 2.0f };
+ LayoutProperty<bool> textKeepUpright { true };
+ LayoutProperty<TextTransformType> textTransform { TextTransformType::None };
+ LayoutProperty<std::array<float, 2>> textOffset { {{ 0, 0 }} };
+ LayoutProperty<bool> textAllowOverlap { false };
+ LayoutProperty<bool> textIgnorePlacement { false };
+ LayoutProperty<bool> textOptional { false };
// Special case.
float iconMaxSize = 1.0f;
@@ -58,28 +52,30 @@ public:
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 };
+ PaintProperty<float> iconOpacity { 1.0f };
+ PaintProperty<Color> iconColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<Color> iconHaloColor { {{ 0, 0, 0, 0 }} };
+ PaintProperty<float> iconHaloWidth { 0.0f };
+ PaintProperty<float> iconHaloBlur { 0.0f };
+ PaintProperty<std::array<float, 2>> iconTranslate { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> iconTranslateAnchor { TranslateAnchorType::Map };
+
+ PaintProperty<float> textOpacity { 1.0f };
+ PaintProperty<Color> textColor { {{ 0, 0, 0, 1 }} };
+ PaintProperty<Color> textHaloColor { {{ 0, 0, 0, 0 }} };
+ PaintProperty<float> textHaloWidth { 0.0f };
+ PaintProperty<float> textHaloBlur { 0.0f };
+ PaintProperty<std::array<float, 2>> textTranslate { {{ 0, 0 }} };
+ PaintProperty<TranslateAnchorType> textTranslateAnchor { TranslateAnchorType::Map };
+
+ // Special case
+ float iconSize = 1.0f;
+ float textSize = 16.0f;
+
+ bool isVisible() const {
+ return (iconOpacity > 0 && (iconColor.value[3] > 0 || iconHaloColor.value[3] > 0) && iconSize > 0)
+ || (textOpacity > 0 && (textColor.value[3] > 0 || textHaloColor.value[3] > 0) && textSize > 0);
+ }
};
class SymbolLayer : public StyleLayer {
View Lorry Controller Status