[core] Introduce Layer::getPaintProperty() generic getter

This commit is contained in:
Mikhail Pozdnyakov
2019-09-24 23:06:05 +03:00
parent 2b834001cc
commit c2dc873cf9
25 changed files with 892 additions and 392 deletions

View File

@@ -2,7 +2,9 @@
#include <mbgl/style/color_ramp_property_value.hpp>
#include <mbgl/style/conversion.hpp>
#include <mbgl/style/layer.hpp>
#include <mbgl/style/property_value.hpp>
#include <mbgl/style/transition_options.hpp>
#include <mbgl/util/feature.hpp>
#include <mbgl/util/geojson.hpp>
#include <mbgl/util/optional.hpp>
@@ -10,6 +12,7 @@
#include <mapbox/value.hpp>
#include <array>
#include <chrono>
#include <string>
#include <type_traits>
@@ -313,6 +316,18 @@ struct ValueFactory<ColorRampPropertyValue> {
static Value make(const ColorRampPropertyValue& value) { return value.getExpression().serialize(); }
};
template <>
struct ValueFactory<TransitionOptions> {
static Value make(const TransitionOptions& value) {
return mapbox::base::ValueArray{
{std::chrono::duration_cast<std::chrono::milliseconds>(value.duration.value_or(mbgl::Duration::zero()))
.count(),
std::chrono::duration_cast<std::chrono::milliseconds>(value.delay.value_or(mbgl::Duration::zero()))
.count(),
value.enablePlacementTransitions}};
}
};
template <>
struct ValueFactory<Color> {
static Value make(const Color& color) { return color.toObject(); }
@@ -334,10 +349,22 @@ Value makeValue(T&& arg) {
}
template <typename T>
Value makeValue(const PropertyValue<T>& value) {
return value.match([](const Undefined&) -> Value { return {}; },
[](const T& t) -> Value { return makeValue(t); },
[](const PropertyExpression<T>& fn) { return fn.getExpression().serialize(); });
LayerProperty makeLayerProperty(const PropertyValue<T>& value) {
return value.match([](const Undefined&) -> LayerProperty { return {}; },
[](const T& t) -> LayerProperty {
return {makeValue(t), LayerProperty::Kind::Constant};
},
[](const PropertyExpression<T>& fn) -> LayerProperty {
return {fn.getExpression().serialize(), LayerProperty::Kind::Expression};
});
}
inline LayerProperty makeLayerProperty(const TransitionOptions& value) {
return {makeValue(value), LayerProperty::Kind::Transition};
}
inline LayerProperty makeLayerProperty(const ColorRampPropertyValue& value) {
return {makeValue(value), LayerProperty::Kind::Expression};
}
} // namespace conversion

View File

@@ -1,9 +1,10 @@
#pragma once
#include <mbgl/style/conversion.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/util/feature.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/style/conversion.hpp>
#include <mapbox/weak.hpp>
#include <mapbox/type_wrapper.hpp>
@@ -65,6 +66,14 @@ struct LayerTypeInfo {
const enum class TileKind : uint8_t { Geometry, Raster, RasterDEM, NotRequired } tileKind;
};
struct LayerProperty {
enum class Kind : uint8_t { Undefined, Constant, Expression, Transition };
LayerProperty(Value value_, Kind kind_) : value(std::move(value_)), kind(kind_) {}
LayerProperty() = default;
const Value value;
const Kind kind = Kind::Undefined;
};
/**
* The runtime representation of a [layer](https://www.mapbox.com/mapbox-gl-style-spec/#layers) from the Mapbox Style
* Specification.
@@ -110,9 +119,12 @@ public:
// Dynamic properties
virtual optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) = 0;
virtual optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) = 0;
virtual optional<conversion::Error> setPaintProperty(const std::string& name,
const conversion::Convertible& value) = 0;
optional<conversion::Error> setVisibility(const conversion::Convertible& value);
virtual LayerProperty getPaintProperty(const std::string&) const = 0;
// Private implementation
// TODO : We should not have public mutable data members.
class Impl;

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<Color> getDefaultBackgroundColor();

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<float> getDefaultCircleBlur();

View File

@@ -71,7 +71,7 @@ public:
// Dynamic properties
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string&) const final;
// Private implementation
class Impl;

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<float> getDefaultFillExtrusionBase();

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<bool> getDefaultFillAntialias();

View File

@@ -25,6 +25,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static ColorRampPropertyValue getDefaultHeatmapColor();

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<Color> getDefaultHillshadeAccentColor();

View File

@@ -40,6 +40,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
<% if (layoutProperties.length) { -%>
// Layout properties

View File

@@ -27,6 +27,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Layout properties
static PropertyValue<LineCapType> getDefaultLineCap();

View File

@@ -24,6 +24,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Paint properties
static PropertyValue<float> getDefaultRasterBrightnessMax();

View File

@@ -26,6 +26,8 @@ public:
optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) final;
optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) final;
LayerProperty getPaintProperty(const std::string& name) const final;
// Layout properties
static PropertyValue<bool> getDefaultIconAllowOverlap();

View File

@@ -148,27 +148,30 @@ TransitionOptions BackgroundLayer::getBackgroundPatternTransition() const {
using namespace conversion;
namespace {
enum class Property {
BackgroundColor,
BackgroundOpacity,
BackgroundPattern,
BackgroundColorTransition,
BackgroundOpacityTransition,
BackgroundPatternTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"background-color", mbgl::underlying_type(Property::BackgroundColor)},
{"background-opacity", mbgl::underlying_type(Property::BackgroundOpacity)},
{"background-pattern", mbgl::underlying_type(Property::BackgroundPattern)},
{"background-color-transition", mbgl::underlying_type(Property::BackgroundColorTransition)},
{"background-opacity-transition", mbgl::underlying_type(Property::BackgroundOpacityTransition)},
{"background-pattern-transition", mbgl::underlying_type(Property::BackgroundPatternTransition)}});
} // namespace
optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
BackgroundColor,
BackgroundOpacity,
BackgroundPattern,
BackgroundColorTransition,
BackgroundOpacityTransition,
BackgroundPatternTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "background-color", mbgl::underlying_type(Property::BackgroundColor) },
{ "background-opacity", mbgl::underlying_type(Property::BackgroundOpacity) },
{ "background-pattern", mbgl::underlying_type(Property::BackgroundPattern) },
{ "background-color-transition", mbgl::underlying_type(Property::BackgroundColorTransition) },
{ "background-opacity-transition", mbgl::underlying_type(Property::BackgroundOpacityTransition) },
{ "background-pattern-transition", mbgl::underlying_type(Property::BackgroundPatternTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -237,6 +240,29 @@ optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const
return Error { "layer doesn't support this property" };
}
LayerProperty BackgroundLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::BackgroundColor:
return conversion::makeLayerProperty(getBackgroundColor());
case Property::BackgroundOpacity:
return conversion::makeLayerProperty(getBackgroundOpacity());
case Property::BackgroundPattern:
return conversion::makeLayerProperty(getBackgroundPattern());
case Property::BackgroundColorTransition:
return conversion::makeLayerProperty(getBackgroundColorTransition());
case Property::BackgroundOpacityTransition:
return conversion::makeLayerProperty(getBackgroundOpacityTransition());
case Property::BackgroundPatternTransition:
return conversion::makeLayerProperty(getBackgroundPatternTransition());
}
return {};
}
optional<Error> BackgroundLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -364,59 +364,62 @@ TransitionOptions CircleLayer::getCircleTranslateAnchorTransition() const {
using namespace conversion;
namespace {
enum class Property {
CircleBlur,
CircleColor,
CircleOpacity,
CirclePitchAlignment,
CirclePitchScale,
CircleRadius,
CircleStrokeColor,
CircleStrokeOpacity,
CircleStrokeWidth,
CircleTranslate,
CircleTranslateAnchor,
CircleBlurTransition,
CircleColorTransition,
CircleOpacityTransition,
CirclePitchAlignmentTransition,
CirclePitchScaleTransition,
CircleRadiusTransition,
CircleStrokeColorTransition,
CircleStrokeOpacityTransition,
CircleStrokeWidthTransition,
CircleTranslateTransition,
CircleTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"circle-blur", mbgl::underlying_type(Property::CircleBlur)},
{"circle-color", mbgl::underlying_type(Property::CircleColor)},
{"circle-opacity", mbgl::underlying_type(Property::CircleOpacity)},
{"circle-pitch-alignment", mbgl::underlying_type(Property::CirclePitchAlignment)},
{"circle-pitch-scale", mbgl::underlying_type(Property::CirclePitchScale)},
{"circle-radius", mbgl::underlying_type(Property::CircleRadius)},
{"circle-stroke-color", mbgl::underlying_type(Property::CircleStrokeColor)},
{"circle-stroke-opacity", mbgl::underlying_type(Property::CircleStrokeOpacity)},
{"circle-stroke-width", mbgl::underlying_type(Property::CircleStrokeWidth)},
{"circle-translate", mbgl::underlying_type(Property::CircleTranslate)},
{"circle-translate-anchor", mbgl::underlying_type(Property::CircleTranslateAnchor)},
{"circle-blur-transition", mbgl::underlying_type(Property::CircleBlurTransition)},
{"circle-color-transition", mbgl::underlying_type(Property::CircleColorTransition)},
{"circle-opacity-transition", mbgl::underlying_type(Property::CircleOpacityTransition)},
{"circle-pitch-alignment-transition", mbgl::underlying_type(Property::CirclePitchAlignmentTransition)},
{"circle-pitch-scale-transition", mbgl::underlying_type(Property::CirclePitchScaleTransition)},
{"circle-radius-transition", mbgl::underlying_type(Property::CircleRadiusTransition)},
{"circle-stroke-color-transition", mbgl::underlying_type(Property::CircleStrokeColorTransition)},
{"circle-stroke-opacity-transition", mbgl::underlying_type(Property::CircleStrokeOpacityTransition)},
{"circle-stroke-width-transition", mbgl::underlying_type(Property::CircleStrokeWidthTransition)},
{"circle-translate-transition", mbgl::underlying_type(Property::CircleTranslateTransition)},
{"circle-translate-anchor-transition", mbgl::underlying_type(Property::CircleTranslateAnchorTransition)}});
} // namespace
optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
CircleBlur,
CircleColor,
CircleOpacity,
CirclePitchAlignment,
CirclePitchScale,
CircleRadius,
CircleStrokeColor,
CircleStrokeOpacity,
CircleStrokeWidth,
CircleTranslate,
CircleTranslateAnchor,
CircleBlurTransition,
CircleColorTransition,
CircleOpacityTransition,
CirclePitchAlignmentTransition,
CirclePitchScaleTransition,
CircleRadiusTransition,
CircleStrokeColorTransition,
CircleStrokeOpacityTransition,
CircleStrokeWidthTransition,
CircleTranslateTransition,
CircleTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "circle-blur", mbgl::underlying_type(Property::CircleBlur) },
{ "circle-color", mbgl::underlying_type(Property::CircleColor) },
{ "circle-opacity", mbgl::underlying_type(Property::CircleOpacity) },
{ "circle-pitch-alignment", mbgl::underlying_type(Property::CirclePitchAlignment) },
{ "circle-pitch-scale", mbgl::underlying_type(Property::CirclePitchScale) },
{ "circle-radius", mbgl::underlying_type(Property::CircleRadius) },
{ "circle-stroke-color", mbgl::underlying_type(Property::CircleStrokeColor) },
{ "circle-stroke-opacity", mbgl::underlying_type(Property::CircleStrokeOpacity) },
{ "circle-stroke-width", mbgl::underlying_type(Property::CircleStrokeWidth) },
{ "circle-translate", mbgl::underlying_type(Property::CircleTranslate) },
{ "circle-translate-anchor", mbgl::underlying_type(Property::CircleTranslateAnchor) },
{ "circle-blur-transition", mbgl::underlying_type(Property::CircleBlurTransition) },
{ "circle-color-transition", mbgl::underlying_type(Property::CircleColorTransition) },
{ "circle-opacity-transition", mbgl::underlying_type(Property::CircleOpacityTransition) },
{ "circle-pitch-alignment-transition", mbgl::underlying_type(Property::CirclePitchAlignmentTransition) },
{ "circle-pitch-scale-transition", mbgl::underlying_type(Property::CirclePitchScaleTransition) },
{ "circle-radius-transition", mbgl::underlying_type(Property::CircleRadiusTransition) },
{ "circle-stroke-color-transition", mbgl::underlying_type(Property::CircleStrokeColorTransition) },
{ "circle-stroke-opacity-transition", mbgl::underlying_type(Property::CircleStrokeOpacityTransition) },
{ "circle-stroke-width-transition", mbgl::underlying_type(Property::CircleStrokeWidthTransition) },
{ "circle-translate-transition", mbgl::underlying_type(Property::CircleTranslateTransition) },
{ "circle-translate-anchor-transition", mbgl::underlying_type(Property::CircleTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -590,6 +593,61 @@ optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Con
return Error { "layer doesn't support this property" };
}
LayerProperty CircleLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::CircleBlur:
return conversion::makeLayerProperty(getCircleBlur());
case Property::CircleColor:
return conversion::makeLayerProperty(getCircleColor());
case Property::CircleOpacity:
return conversion::makeLayerProperty(getCircleOpacity());
case Property::CirclePitchAlignment:
return conversion::makeLayerProperty(getCirclePitchAlignment());
case Property::CirclePitchScale:
return conversion::makeLayerProperty(getCirclePitchScale());
case Property::CircleRadius:
return conversion::makeLayerProperty(getCircleRadius());
case Property::CircleStrokeColor:
return conversion::makeLayerProperty(getCircleStrokeColor());
case Property::CircleStrokeOpacity:
return conversion::makeLayerProperty(getCircleStrokeOpacity());
case Property::CircleStrokeWidth:
return conversion::makeLayerProperty(getCircleStrokeWidth());
case Property::CircleTranslate:
return conversion::makeLayerProperty(getCircleTranslate());
case Property::CircleTranslateAnchor:
return conversion::makeLayerProperty(getCircleTranslateAnchor());
case Property::CircleBlurTransition:
return conversion::makeLayerProperty(getCircleBlurTransition());
case Property::CircleColorTransition:
return conversion::makeLayerProperty(getCircleColorTransition());
case Property::CircleOpacityTransition:
return conversion::makeLayerProperty(getCircleOpacityTransition());
case Property::CirclePitchAlignmentTransition:
return conversion::makeLayerProperty(getCirclePitchAlignmentTransition());
case Property::CirclePitchScaleTransition:
return conversion::makeLayerProperty(getCirclePitchScaleTransition());
case Property::CircleRadiusTransition:
return conversion::makeLayerProperty(getCircleRadiusTransition());
case Property::CircleStrokeColorTransition:
return conversion::makeLayerProperty(getCircleStrokeColorTransition());
case Property::CircleStrokeOpacityTransition:
return conversion::makeLayerProperty(getCircleStrokeOpacityTransition());
case Property::CircleStrokeWidthTransition:
return conversion::makeLayerProperty(getCircleStrokeWidthTransition());
case Property::CircleTranslateTransition:
return conversion::makeLayerProperty(getCircleTranslateTransition());
case Property::CircleTranslateAnchorTransition:
return conversion::makeLayerProperty(getCircleTranslateAnchorTransition());
}
return {};
}
optional<Error> CircleLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -47,6 +47,10 @@ optional<Error> CustomLayer::setLayoutProperty(const std::string&, const Convert
return Error { "layer doesn't support this property" };
}
LayerProperty CustomLayer::getPaintProperty(const std::string&) const {
return {};
}
Mutable<Layer::Impl> CustomLayer::mutableBaseImpl() const {
return staticMutableCast<Layer::Impl>(mutableImpl());
}

View File

@@ -283,47 +283,50 @@ TransitionOptions FillExtrusionLayer::getFillExtrusionVerticalGradientTransition
using namespace conversion;
namespace {
enum class Property {
FillExtrusionBase,
FillExtrusionColor,
FillExtrusionHeight,
FillExtrusionOpacity,
FillExtrusionPattern,
FillExtrusionTranslate,
FillExtrusionTranslateAnchor,
FillExtrusionVerticalGradient,
FillExtrusionBaseTransition,
FillExtrusionColorTransition,
FillExtrusionHeightTransition,
FillExtrusionOpacityTransition,
FillExtrusionPatternTransition,
FillExtrusionTranslateTransition,
FillExtrusionTranslateAnchorTransition,
FillExtrusionVerticalGradientTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"fill-extrusion-base", mbgl::underlying_type(Property::FillExtrusionBase)},
{"fill-extrusion-color", mbgl::underlying_type(Property::FillExtrusionColor)},
{"fill-extrusion-height", mbgl::underlying_type(Property::FillExtrusionHeight)},
{"fill-extrusion-opacity", mbgl::underlying_type(Property::FillExtrusionOpacity)},
{"fill-extrusion-pattern", mbgl::underlying_type(Property::FillExtrusionPattern)},
{"fill-extrusion-translate", mbgl::underlying_type(Property::FillExtrusionTranslate)},
{"fill-extrusion-translate-anchor", mbgl::underlying_type(Property::FillExtrusionTranslateAnchor)},
{"fill-extrusion-vertical-gradient", mbgl::underlying_type(Property::FillExtrusionVerticalGradient)},
{"fill-extrusion-base-transition", mbgl::underlying_type(Property::FillExtrusionBaseTransition)},
{"fill-extrusion-color-transition", mbgl::underlying_type(Property::FillExtrusionColorTransition)},
{"fill-extrusion-height-transition", mbgl::underlying_type(Property::FillExtrusionHeightTransition)},
{"fill-extrusion-opacity-transition", mbgl::underlying_type(Property::FillExtrusionOpacityTransition)},
{"fill-extrusion-pattern-transition", mbgl::underlying_type(Property::FillExtrusionPatternTransition)},
{"fill-extrusion-translate-transition", mbgl::underlying_type(Property::FillExtrusionTranslateTransition)},
{"fill-extrusion-translate-anchor-transition", mbgl::underlying_type(Property::FillExtrusionTranslateAnchorTransition)},
{"fill-extrusion-vertical-gradient-transition", mbgl::underlying_type(Property::FillExtrusionVerticalGradientTransition)}});
} // namespace
optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
FillExtrusionBase,
FillExtrusionColor,
FillExtrusionHeight,
FillExtrusionOpacity,
FillExtrusionPattern,
FillExtrusionTranslate,
FillExtrusionTranslateAnchor,
FillExtrusionVerticalGradient,
FillExtrusionBaseTransition,
FillExtrusionColorTransition,
FillExtrusionHeightTransition,
FillExtrusionOpacityTransition,
FillExtrusionPatternTransition,
FillExtrusionTranslateTransition,
FillExtrusionTranslateAnchorTransition,
FillExtrusionVerticalGradientTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "fill-extrusion-base", mbgl::underlying_type(Property::FillExtrusionBase) },
{ "fill-extrusion-color", mbgl::underlying_type(Property::FillExtrusionColor) },
{ "fill-extrusion-height", mbgl::underlying_type(Property::FillExtrusionHeight) },
{ "fill-extrusion-opacity", mbgl::underlying_type(Property::FillExtrusionOpacity) },
{ "fill-extrusion-pattern", mbgl::underlying_type(Property::FillExtrusionPattern) },
{ "fill-extrusion-translate", mbgl::underlying_type(Property::FillExtrusionTranslate) },
{ "fill-extrusion-translate-anchor", mbgl::underlying_type(Property::FillExtrusionTranslateAnchor) },
{ "fill-extrusion-vertical-gradient", mbgl::underlying_type(Property::FillExtrusionVerticalGradient) },
{ "fill-extrusion-base-transition", mbgl::underlying_type(Property::FillExtrusionBaseTransition) },
{ "fill-extrusion-color-transition", mbgl::underlying_type(Property::FillExtrusionColorTransition) },
{ "fill-extrusion-height-transition", mbgl::underlying_type(Property::FillExtrusionHeightTransition) },
{ "fill-extrusion-opacity-transition", mbgl::underlying_type(Property::FillExtrusionOpacityTransition) },
{ "fill-extrusion-pattern-transition", mbgl::underlying_type(Property::FillExtrusionPatternTransition) },
{ "fill-extrusion-translate-transition", mbgl::underlying_type(Property::FillExtrusionTranslateTransition) },
{ "fill-extrusion-translate-anchor-transition", mbgl::underlying_type(Property::FillExtrusionTranslateAnchorTransition) },
{ "fill-extrusion-vertical-gradient-transition", mbgl::underlying_type(Property::FillExtrusionVerticalGradientTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -472,6 +475,49 @@ optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, co
return Error { "layer doesn't support this property" };
}
LayerProperty FillExtrusionLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::FillExtrusionBase:
return conversion::makeLayerProperty(getFillExtrusionBase());
case Property::FillExtrusionColor:
return conversion::makeLayerProperty(getFillExtrusionColor());
case Property::FillExtrusionHeight:
return conversion::makeLayerProperty(getFillExtrusionHeight());
case Property::FillExtrusionOpacity:
return conversion::makeLayerProperty(getFillExtrusionOpacity());
case Property::FillExtrusionPattern:
return conversion::makeLayerProperty(getFillExtrusionPattern());
case Property::FillExtrusionTranslate:
return conversion::makeLayerProperty(getFillExtrusionTranslate());
case Property::FillExtrusionTranslateAnchor:
return conversion::makeLayerProperty(getFillExtrusionTranslateAnchor());
case Property::FillExtrusionVerticalGradient:
return conversion::makeLayerProperty(getFillExtrusionVerticalGradient());
case Property::FillExtrusionBaseTransition:
return conversion::makeLayerProperty(getFillExtrusionBaseTransition());
case Property::FillExtrusionColorTransition:
return conversion::makeLayerProperty(getFillExtrusionColorTransition());
case Property::FillExtrusionHeightTransition:
return conversion::makeLayerProperty(getFillExtrusionHeightTransition());
case Property::FillExtrusionOpacityTransition:
return conversion::makeLayerProperty(getFillExtrusionOpacityTransition());
case Property::FillExtrusionPatternTransition:
return conversion::makeLayerProperty(getFillExtrusionPatternTransition());
case Property::FillExtrusionTranslateTransition:
return conversion::makeLayerProperty(getFillExtrusionTranslateTransition());
case Property::FillExtrusionTranslateAnchorTransition:
return conversion::makeLayerProperty(getFillExtrusionTranslateAnchorTransition());
case Property::FillExtrusionVerticalGradientTransition:
return conversion::makeLayerProperty(getFillExtrusionVerticalGradientTransition());
}
return {};
}
optional<Error> FillExtrusionLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -256,43 +256,46 @@ TransitionOptions FillLayer::getFillTranslateAnchorTransition() const {
using namespace conversion;
namespace {
enum class Property {
FillAntialias,
FillColor,
FillOpacity,
FillOutlineColor,
FillPattern,
FillTranslate,
FillTranslateAnchor,
FillAntialiasTransition,
FillColorTransition,
FillOpacityTransition,
FillOutlineColorTransition,
FillPatternTransition,
FillTranslateTransition,
FillTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"fill-antialias", mbgl::underlying_type(Property::FillAntialias)},
{"fill-color", mbgl::underlying_type(Property::FillColor)},
{"fill-opacity", mbgl::underlying_type(Property::FillOpacity)},
{"fill-outline-color", mbgl::underlying_type(Property::FillOutlineColor)},
{"fill-pattern", mbgl::underlying_type(Property::FillPattern)},
{"fill-translate", mbgl::underlying_type(Property::FillTranslate)},
{"fill-translate-anchor", mbgl::underlying_type(Property::FillTranslateAnchor)},
{"fill-antialias-transition", mbgl::underlying_type(Property::FillAntialiasTransition)},
{"fill-color-transition", mbgl::underlying_type(Property::FillColorTransition)},
{"fill-opacity-transition", mbgl::underlying_type(Property::FillOpacityTransition)},
{"fill-outline-color-transition", mbgl::underlying_type(Property::FillOutlineColorTransition)},
{"fill-pattern-transition", mbgl::underlying_type(Property::FillPatternTransition)},
{"fill-translate-transition", mbgl::underlying_type(Property::FillTranslateTransition)},
{"fill-translate-anchor-transition", mbgl::underlying_type(Property::FillTranslateAnchorTransition)}});
} // namespace
optional<Error> FillLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
FillAntialias,
FillColor,
FillOpacity,
FillOutlineColor,
FillPattern,
FillTranslate,
FillTranslateAnchor,
FillAntialiasTransition,
FillColorTransition,
FillOpacityTransition,
FillOutlineColorTransition,
FillPatternTransition,
FillTranslateTransition,
FillTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "fill-antialias", mbgl::underlying_type(Property::FillAntialias) },
{ "fill-color", mbgl::underlying_type(Property::FillColor) },
{ "fill-opacity", mbgl::underlying_type(Property::FillOpacity) },
{ "fill-outline-color", mbgl::underlying_type(Property::FillOutlineColor) },
{ "fill-pattern", mbgl::underlying_type(Property::FillPattern) },
{ "fill-translate", mbgl::underlying_type(Property::FillTranslate) },
{ "fill-translate-anchor", mbgl::underlying_type(Property::FillTranslateAnchor) },
{ "fill-antialias-transition", mbgl::underlying_type(Property::FillAntialiasTransition) },
{ "fill-color-transition", mbgl::underlying_type(Property::FillColorTransition) },
{ "fill-opacity-transition", mbgl::underlying_type(Property::FillOpacityTransition) },
{ "fill-outline-color-transition", mbgl::underlying_type(Property::FillOutlineColorTransition) },
{ "fill-pattern-transition", mbgl::underlying_type(Property::FillPatternTransition) },
{ "fill-translate-transition", mbgl::underlying_type(Property::FillTranslateTransition) },
{ "fill-translate-anchor-transition", mbgl::underlying_type(Property::FillTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -424,6 +427,45 @@ optional<Error> FillLayer::setPaintProperty(const std::string& name, const Conve
return Error { "layer doesn't support this property" };
}
LayerProperty FillLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::FillAntialias:
return conversion::makeLayerProperty(getFillAntialias());
case Property::FillColor:
return conversion::makeLayerProperty(getFillColor());
case Property::FillOpacity:
return conversion::makeLayerProperty(getFillOpacity());
case Property::FillOutlineColor:
return conversion::makeLayerProperty(getFillOutlineColor());
case Property::FillPattern:
return conversion::makeLayerProperty(getFillPattern());
case Property::FillTranslate:
return conversion::makeLayerProperty(getFillTranslate());
case Property::FillTranslateAnchor:
return conversion::makeLayerProperty(getFillTranslateAnchor());
case Property::FillAntialiasTransition:
return conversion::makeLayerProperty(getFillAntialiasTransition());
case Property::FillColorTransition:
return conversion::makeLayerProperty(getFillColorTransition());
case Property::FillOpacityTransition:
return conversion::makeLayerProperty(getFillOpacityTransition());
case Property::FillOutlineColorTransition:
return conversion::makeLayerProperty(getFillOutlineColorTransition());
case Property::FillPatternTransition:
return conversion::makeLayerProperty(getFillPatternTransition());
case Property::FillTranslateTransition:
return conversion::makeLayerProperty(getFillTranslateTransition());
case Property::FillTranslateAnchorTransition:
return conversion::makeLayerProperty(getFillTranslateAnchorTransition());
}
return {};
}
optional<Error> FillLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -204,35 +204,38 @@ TransitionOptions HeatmapLayer::getHeatmapWeightTransition() const {
using namespace conversion;
namespace {
enum class Property {
HeatmapColor,
HeatmapIntensity,
HeatmapOpacity,
HeatmapRadius,
HeatmapWeight,
HeatmapColorTransition,
HeatmapIntensityTransition,
HeatmapOpacityTransition,
HeatmapRadiusTransition,
HeatmapWeightTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"heatmap-color", mbgl::underlying_type(Property::HeatmapColor)},
{"heatmap-intensity", mbgl::underlying_type(Property::HeatmapIntensity)},
{"heatmap-opacity", mbgl::underlying_type(Property::HeatmapOpacity)},
{"heatmap-radius", mbgl::underlying_type(Property::HeatmapRadius)},
{"heatmap-weight", mbgl::underlying_type(Property::HeatmapWeight)},
{"heatmap-color-transition", mbgl::underlying_type(Property::HeatmapColorTransition)},
{"heatmap-intensity-transition", mbgl::underlying_type(Property::HeatmapIntensityTransition)},
{"heatmap-opacity-transition", mbgl::underlying_type(Property::HeatmapOpacityTransition)},
{"heatmap-radius-transition", mbgl::underlying_type(Property::HeatmapRadiusTransition)},
{"heatmap-weight-transition", mbgl::underlying_type(Property::HeatmapWeightTransition)}});
} // namespace
optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
HeatmapColor,
HeatmapIntensity,
HeatmapOpacity,
HeatmapRadius,
HeatmapWeight,
HeatmapColorTransition,
HeatmapIntensityTransition,
HeatmapOpacityTransition,
HeatmapRadiusTransition,
HeatmapWeightTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "heatmap-color", mbgl::underlying_type(Property::HeatmapColor) },
{ "heatmap-intensity", mbgl::underlying_type(Property::HeatmapIntensity) },
{ "heatmap-opacity", mbgl::underlying_type(Property::HeatmapOpacity) },
{ "heatmap-radius", mbgl::underlying_type(Property::HeatmapRadius) },
{ "heatmap-weight", mbgl::underlying_type(Property::HeatmapWeight) },
{ "heatmap-color-transition", mbgl::underlying_type(Property::HeatmapColorTransition) },
{ "heatmap-intensity-transition", mbgl::underlying_type(Property::HeatmapIntensityTransition) },
{ "heatmap-opacity-transition", mbgl::underlying_type(Property::HeatmapOpacityTransition) },
{ "heatmap-radius-transition", mbgl::underlying_type(Property::HeatmapRadiusTransition) },
{ "heatmap-weight-transition", mbgl::underlying_type(Property::HeatmapWeightTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -325,6 +328,37 @@ optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Co
return Error { "layer doesn't support this property" };
}
LayerProperty HeatmapLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::HeatmapColor:
return conversion::makeLayerProperty(getHeatmapColor());
case Property::HeatmapIntensity:
return conversion::makeLayerProperty(getHeatmapIntensity());
case Property::HeatmapOpacity:
return conversion::makeLayerProperty(getHeatmapOpacity());
case Property::HeatmapRadius:
return conversion::makeLayerProperty(getHeatmapRadius());
case Property::HeatmapWeight:
return conversion::makeLayerProperty(getHeatmapWeight());
case Property::HeatmapColorTransition:
return conversion::makeLayerProperty(getHeatmapColorTransition());
case Property::HeatmapIntensityTransition:
return conversion::makeLayerProperty(getHeatmapIntensityTransition());
case Property::HeatmapOpacityTransition:
return conversion::makeLayerProperty(getHeatmapOpacityTransition());
case Property::HeatmapRadiusTransition:
return conversion::makeLayerProperty(getHeatmapRadiusTransition());
case Property::HeatmapWeightTransition:
return conversion::makeLayerProperty(getHeatmapWeightTransition());
}
return {};
}
optional<Error> HeatmapLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -229,39 +229,42 @@ TransitionOptions HillshadeLayer::getHillshadeShadowColorTransition() const {
using namespace conversion;
namespace {
enum class Property {
HillshadeAccentColor,
HillshadeExaggeration,
HillshadeHighlightColor,
HillshadeIlluminationAnchor,
HillshadeIlluminationDirection,
HillshadeShadowColor,
HillshadeAccentColorTransition,
HillshadeExaggerationTransition,
HillshadeHighlightColorTransition,
HillshadeIlluminationAnchorTransition,
HillshadeIlluminationDirectionTransition,
HillshadeShadowColorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"hillshade-accent-color", mbgl::underlying_type(Property::HillshadeAccentColor)},
{"hillshade-exaggeration", mbgl::underlying_type(Property::HillshadeExaggeration)},
{"hillshade-highlight-color", mbgl::underlying_type(Property::HillshadeHighlightColor)},
{"hillshade-illumination-anchor", mbgl::underlying_type(Property::HillshadeIlluminationAnchor)},
{"hillshade-illumination-direction", mbgl::underlying_type(Property::HillshadeIlluminationDirection)},
{"hillshade-shadow-color", mbgl::underlying_type(Property::HillshadeShadowColor)},
{"hillshade-accent-color-transition", mbgl::underlying_type(Property::HillshadeAccentColorTransition)},
{"hillshade-exaggeration-transition", mbgl::underlying_type(Property::HillshadeExaggerationTransition)},
{"hillshade-highlight-color-transition", mbgl::underlying_type(Property::HillshadeHighlightColorTransition)},
{"hillshade-illumination-anchor-transition", mbgl::underlying_type(Property::HillshadeIlluminationAnchorTransition)},
{"hillshade-illumination-direction-transition", mbgl::underlying_type(Property::HillshadeIlluminationDirectionTransition)},
{"hillshade-shadow-color-transition", mbgl::underlying_type(Property::HillshadeShadowColorTransition)}});
} // namespace
optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
HillshadeAccentColor,
HillshadeExaggeration,
HillshadeHighlightColor,
HillshadeIlluminationAnchor,
HillshadeIlluminationDirection,
HillshadeShadowColor,
HillshadeAccentColorTransition,
HillshadeExaggerationTransition,
HillshadeHighlightColorTransition,
HillshadeIlluminationAnchorTransition,
HillshadeIlluminationDirectionTransition,
HillshadeShadowColorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "hillshade-accent-color", mbgl::underlying_type(Property::HillshadeAccentColor) },
{ "hillshade-exaggeration", mbgl::underlying_type(Property::HillshadeExaggeration) },
{ "hillshade-highlight-color", mbgl::underlying_type(Property::HillshadeHighlightColor) },
{ "hillshade-illumination-anchor", mbgl::underlying_type(Property::HillshadeIlluminationAnchor) },
{ "hillshade-illumination-direction", mbgl::underlying_type(Property::HillshadeIlluminationDirection) },
{ "hillshade-shadow-color", mbgl::underlying_type(Property::HillshadeShadowColor) },
{ "hillshade-accent-color-transition", mbgl::underlying_type(Property::HillshadeAccentColorTransition) },
{ "hillshade-exaggeration-transition", mbgl::underlying_type(Property::HillshadeExaggerationTransition) },
{ "hillshade-highlight-color-transition", mbgl::underlying_type(Property::HillshadeHighlightColorTransition) },
{ "hillshade-illumination-anchor-transition", mbgl::underlying_type(Property::HillshadeIlluminationAnchorTransition) },
{ "hillshade-illumination-direction-transition", mbgl::underlying_type(Property::HillshadeIlluminationDirectionTransition) },
{ "hillshade-shadow-color-transition", mbgl::underlying_type(Property::HillshadeShadowColorTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -364,6 +367,41 @@ optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const
return Error { "layer doesn't support this property" };
}
LayerProperty HillshadeLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::HillshadeAccentColor:
return conversion::makeLayerProperty(getHillshadeAccentColor());
case Property::HillshadeExaggeration:
return conversion::makeLayerProperty(getHillshadeExaggeration());
case Property::HillshadeHighlightColor:
return conversion::makeLayerProperty(getHillshadeHighlightColor());
case Property::HillshadeIlluminationAnchor:
return conversion::makeLayerProperty(getHillshadeIlluminationAnchor());
case Property::HillshadeIlluminationDirection:
return conversion::makeLayerProperty(getHillshadeIlluminationDirection());
case Property::HillshadeShadowColor:
return conversion::makeLayerProperty(getHillshadeShadowColor());
case Property::HillshadeAccentColorTransition:
return conversion::makeLayerProperty(getHillshadeAccentColorTransition());
case Property::HillshadeExaggerationTransition:
return conversion::makeLayerProperty(getHillshadeExaggerationTransition());
case Property::HillshadeHighlightColorTransition:
return conversion::makeLayerProperty(getHillshadeHighlightColorTransition());
case Property::HillshadeIlluminationAnchorTransition:
return conversion::makeLayerProperty(getHillshadeIlluminationAnchorTransition());
case Property::HillshadeIlluminationDirectionTransition:
return conversion::makeLayerProperty(getHillshadeIlluminationDirectionTransition());
case Property::HillshadeShadowColorTransition:
return conversion::makeLayerProperty(getHillshadeShadowColorTransition());
}
return {};
}
optional<Error> HillshadeLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -190,23 +190,26 @@ TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>T
using namespace conversion;
namespace {
enum class Property {
<% for (const property of paintProperties) { -%>
<%- camelize(property.name) %>,
<% } -%>
<% for (const property of paintProperties) { -%>
<%- camelize(property.name) %>Transition,
<% } -%>
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{<%- paintProperties.map(p => `{"${p.name}", mbgl::underlying_type(Property::${camelize(p.name)})}`).join(',\n ') %>,
<%- paintProperties.map(p => `{"${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition)}`).join(',\n ') %>});
} // namespace
optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
<% for (const property of paintProperties) { -%>
<%- camelize(property.name) %>,
<% } -%>
<% for (const property of paintProperties) { -%>
<%- camelize(property.name) %>Transition,
<% } -%>
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
<%- paintProperties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n ') %>,
<%- paintProperties.map(p => `{ "${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition) }`).join(',\n ') %>
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -258,6 +261,25 @@ optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string&
return Error { "layer doesn't support this property" };
}
LayerProperty <%- camelize(type) %>Layer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
<% for (const property of paintProperties) { -%>
case Property::<%- camelize(property.name) %>:
return conversion::makeLayerProperty(get<%- camelize(property.name) %>());
<% } -%>
<% for (const property of paintProperties) { -%>
case Property::<%- camelize(property.name) %>Transition:
return conversion::makeLayerProperty(get<%- camelize(property.name) %>Transition());
<% } -%>
}
return {};
}
optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -430,59 +430,62 @@ TransitionOptions LineLayer::getLineWidthTransition() const {
using namespace conversion;
namespace {
enum class Property {
LineBlur,
LineColor,
LineDasharray,
LineGapWidth,
LineGradient,
LineOffset,
LineOpacity,
LinePattern,
LineTranslate,
LineTranslateAnchor,
LineWidth,
LineBlurTransition,
LineColorTransition,
LineDasharrayTransition,
LineGapWidthTransition,
LineGradientTransition,
LineOffsetTransition,
LineOpacityTransition,
LinePatternTransition,
LineTranslateTransition,
LineTranslateAnchorTransition,
LineWidthTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"line-blur", mbgl::underlying_type(Property::LineBlur)},
{"line-color", mbgl::underlying_type(Property::LineColor)},
{"line-dasharray", mbgl::underlying_type(Property::LineDasharray)},
{"line-gap-width", mbgl::underlying_type(Property::LineGapWidth)},
{"line-gradient", mbgl::underlying_type(Property::LineGradient)},
{"line-offset", mbgl::underlying_type(Property::LineOffset)},
{"line-opacity", mbgl::underlying_type(Property::LineOpacity)},
{"line-pattern", mbgl::underlying_type(Property::LinePattern)},
{"line-translate", mbgl::underlying_type(Property::LineTranslate)},
{"line-translate-anchor", mbgl::underlying_type(Property::LineTranslateAnchor)},
{"line-width", mbgl::underlying_type(Property::LineWidth)},
{"line-blur-transition", mbgl::underlying_type(Property::LineBlurTransition)},
{"line-color-transition", mbgl::underlying_type(Property::LineColorTransition)},
{"line-dasharray-transition", mbgl::underlying_type(Property::LineDasharrayTransition)},
{"line-gap-width-transition", mbgl::underlying_type(Property::LineGapWidthTransition)},
{"line-gradient-transition", mbgl::underlying_type(Property::LineGradientTransition)},
{"line-offset-transition", mbgl::underlying_type(Property::LineOffsetTransition)},
{"line-opacity-transition", mbgl::underlying_type(Property::LineOpacityTransition)},
{"line-pattern-transition", mbgl::underlying_type(Property::LinePatternTransition)},
{"line-translate-transition", mbgl::underlying_type(Property::LineTranslateTransition)},
{"line-translate-anchor-transition", mbgl::underlying_type(Property::LineTranslateAnchorTransition)},
{"line-width-transition", mbgl::underlying_type(Property::LineWidthTransition)}});
} // namespace
optional<Error> LineLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
LineBlur,
LineColor,
LineDasharray,
LineGapWidth,
LineGradient,
LineOffset,
LineOpacity,
LinePattern,
LineTranslate,
LineTranslateAnchor,
LineWidth,
LineBlurTransition,
LineColorTransition,
LineDasharrayTransition,
LineGapWidthTransition,
LineGradientTransition,
LineOffsetTransition,
LineOpacityTransition,
LinePatternTransition,
LineTranslateTransition,
LineTranslateAnchorTransition,
LineWidthTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "line-blur", mbgl::underlying_type(Property::LineBlur) },
{ "line-color", mbgl::underlying_type(Property::LineColor) },
{ "line-dasharray", mbgl::underlying_type(Property::LineDasharray) },
{ "line-gap-width", mbgl::underlying_type(Property::LineGapWidth) },
{ "line-gradient", mbgl::underlying_type(Property::LineGradient) },
{ "line-offset", mbgl::underlying_type(Property::LineOffset) },
{ "line-opacity", mbgl::underlying_type(Property::LineOpacity) },
{ "line-pattern", mbgl::underlying_type(Property::LinePattern) },
{ "line-translate", mbgl::underlying_type(Property::LineTranslate) },
{ "line-translate-anchor", mbgl::underlying_type(Property::LineTranslateAnchor) },
{ "line-width", mbgl::underlying_type(Property::LineWidth) },
{ "line-blur-transition", mbgl::underlying_type(Property::LineBlurTransition) },
{ "line-color-transition", mbgl::underlying_type(Property::LineColorTransition) },
{ "line-dasharray-transition", mbgl::underlying_type(Property::LineDasharrayTransition) },
{ "line-gap-width-transition", mbgl::underlying_type(Property::LineGapWidthTransition) },
{ "line-gradient-transition", mbgl::underlying_type(Property::LineGradientTransition) },
{ "line-offset-transition", mbgl::underlying_type(Property::LineOffsetTransition) },
{ "line-opacity-transition", mbgl::underlying_type(Property::LineOpacityTransition) },
{ "line-pattern-transition", mbgl::underlying_type(Property::LinePatternTransition) },
{ "line-translate-transition", mbgl::underlying_type(Property::LineTranslateTransition) },
{ "line-translate-anchor-transition", mbgl::underlying_type(Property::LineTranslateAnchorTransition) },
{ "line-width-transition", mbgl::underlying_type(Property::LineWidthTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -661,6 +664,61 @@ optional<Error> LineLayer::setPaintProperty(const std::string& name, const Conve
return Error { "layer doesn't support this property" };
}
LayerProperty LineLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::LineBlur:
return conversion::makeLayerProperty(getLineBlur());
case Property::LineColor:
return conversion::makeLayerProperty(getLineColor());
case Property::LineDasharray:
return conversion::makeLayerProperty(getLineDasharray());
case Property::LineGapWidth:
return conversion::makeLayerProperty(getLineGapWidth());
case Property::LineGradient:
return conversion::makeLayerProperty(getLineGradient());
case Property::LineOffset:
return conversion::makeLayerProperty(getLineOffset());
case Property::LineOpacity:
return conversion::makeLayerProperty(getLineOpacity());
case Property::LinePattern:
return conversion::makeLayerProperty(getLinePattern());
case Property::LineTranslate:
return conversion::makeLayerProperty(getLineTranslate());
case Property::LineTranslateAnchor:
return conversion::makeLayerProperty(getLineTranslateAnchor());
case Property::LineWidth:
return conversion::makeLayerProperty(getLineWidth());
case Property::LineBlurTransition:
return conversion::makeLayerProperty(getLineBlurTransition());
case Property::LineColorTransition:
return conversion::makeLayerProperty(getLineColorTransition());
case Property::LineDasharrayTransition:
return conversion::makeLayerProperty(getLineDasharrayTransition());
case Property::LineGapWidthTransition:
return conversion::makeLayerProperty(getLineGapWidthTransition());
case Property::LineGradientTransition:
return conversion::makeLayerProperty(getLineGradientTransition());
case Property::LineOffsetTransition:
return conversion::makeLayerProperty(getLineOffsetTransition());
case Property::LineOpacityTransition:
return conversion::makeLayerProperty(getLineOpacityTransition());
case Property::LinePatternTransition:
return conversion::makeLayerProperty(getLinePatternTransition());
case Property::LineTranslateTransition:
return conversion::makeLayerProperty(getLineTranslateTransition());
case Property::LineTranslateAnchorTransition:
return conversion::makeLayerProperty(getLineTranslateAnchorTransition());
case Property::LineWidthTransition:
return conversion::makeLayerProperty(getLineWidthTransition());
}
return {};
}
optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -283,47 +283,50 @@ TransitionOptions RasterLayer::getRasterSaturationTransition() const {
using namespace conversion;
namespace {
enum class Property {
RasterBrightnessMax,
RasterBrightnessMin,
RasterContrast,
RasterFadeDuration,
RasterHueRotate,
RasterOpacity,
RasterResampling,
RasterSaturation,
RasterBrightnessMaxTransition,
RasterBrightnessMinTransition,
RasterContrastTransition,
RasterFadeDurationTransition,
RasterHueRotateTransition,
RasterOpacityTransition,
RasterResamplingTransition,
RasterSaturationTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"raster-brightness-max", mbgl::underlying_type(Property::RasterBrightnessMax)},
{"raster-brightness-min", mbgl::underlying_type(Property::RasterBrightnessMin)},
{"raster-contrast", mbgl::underlying_type(Property::RasterContrast)},
{"raster-fade-duration", mbgl::underlying_type(Property::RasterFadeDuration)},
{"raster-hue-rotate", mbgl::underlying_type(Property::RasterHueRotate)},
{"raster-opacity", mbgl::underlying_type(Property::RasterOpacity)},
{"raster-resampling", mbgl::underlying_type(Property::RasterResampling)},
{"raster-saturation", mbgl::underlying_type(Property::RasterSaturation)},
{"raster-brightness-max-transition", mbgl::underlying_type(Property::RasterBrightnessMaxTransition)},
{"raster-brightness-min-transition", mbgl::underlying_type(Property::RasterBrightnessMinTransition)},
{"raster-contrast-transition", mbgl::underlying_type(Property::RasterContrastTransition)},
{"raster-fade-duration-transition", mbgl::underlying_type(Property::RasterFadeDurationTransition)},
{"raster-hue-rotate-transition", mbgl::underlying_type(Property::RasterHueRotateTransition)},
{"raster-opacity-transition", mbgl::underlying_type(Property::RasterOpacityTransition)},
{"raster-resampling-transition", mbgl::underlying_type(Property::RasterResamplingTransition)},
{"raster-saturation-transition", mbgl::underlying_type(Property::RasterSaturationTransition)}});
} // namespace
optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
RasterBrightnessMax,
RasterBrightnessMin,
RasterContrast,
RasterFadeDuration,
RasterHueRotate,
RasterOpacity,
RasterResampling,
RasterSaturation,
RasterBrightnessMaxTransition,
RasterBrightnessMinTransition,
RasterContrastTransition,
RasterFadeDurationTransition,
RasterHueRotateTransition,
RasterOpacityTransition,
RasterResamplingTransition,
RasterSaturationTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "raster-brightness-max", mbgl::underlying_type(Property::RasterBrightnessMax) },
{ "raster-brightness-min", mbgl::underlying_type(Property::RasterBrightnessMin) },
{ "raster-contrast", mbgl::underlying_type(Property::RasterContrast) },
{ "raster-fade-duration", mbgl::underlying_type(Property::RasterFadeDuration) },
{ "raster-hue-rotate", mbgl::underlying_type(Property::RasterHueRotate) },
{ "raster-opacity", mbgl::underlying_type(Property::RasterOpacity) },
{ "raster-resampling", mbgl::underlying_type(Property::RasterResampling) },
{ "raster-saturation", mbgl::underlying_type(Property::RasterSaturation) },
{ "raster-brightness-max-transition", mbgl::underlying_type(Property::RasterBrightnessMaxTransition) },
{ "raster-brightness-min-transition", mbgl::underlying_type(Property::RasterBrightnessMinTransition) },
{ "raster-contrast-transition", mbgl::underlying_type(Property::RasterContrastTransition) },
{ "raster-fade-duration-transition", mbgl::underlying_type(Property::RasterFadeDurationTransition) },
{ "raster-hue-rotate-transition", mbgl::underlying_type(Property::RasterHueRotateTransition) },
{ "raster-opacity-transition", mbgl::underlying_type(Property::RasterOpacityTransition) },
{ "raster-resampling-transition", mbgl::underlying_type(Property::RasterResamplingTransition) },
{ "raster-saturation-transition", mbgl::underlying_type(Property::RasterSaturationTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -437,6 +440,49 @@ optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Con
return Error { "layer doesn't support this property" };
}
LayerProperty RasterLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::RasterBrightnessMax:
return conversion::makeLayerProperty(getRasterBrightnessMax());
case Property::RasterBrightnessMin:
return conversion::makeLayerProperty(getRasterBrightnessMin());
case Property::RasterContrast:
return conversion::makeLayerProperty(getRasterContrast());
case Property::RasterFadeDuration:
return conversion::makeLayerProperty(getRasterFadeDuration());
case Property::RasterHueRotate:
return conversion::makeLayerProperty(getRasterHueRotate());
case Property::RasterOpacity:
return conversion::makeLayerProperty(getRasterOpacity());
case Property::RasterResampling:
return conversion::makeLayerProperty(getRasterResampling());
case Property::RasterSaturation:
return conversion::makeLayerProperty(getRasterSaturation());
case Property::RasterBrightnessMaxTransition:
return conversion::makeLayerProperty(getRasterBrightnessMaxTransition());
case Property::RasterBrightnessMinTransition:
return conversion::makeLayerProperty(getRasterBrightnessMinTransition());
case Property::RasterContrastTransition:
return conversion::makeLayerProperty(getRasterContrastTransition());
case Property::RasterFadeDurationTransition:
return conversion::makeLayerProperty(getRasterFadeDurationTransition());
case Property::RasterHueRotateTransition:
return conversion::makeLayerProperty(getRasterHueRotateTransition());
case Property::RasterOpacityTransition:
return conversion::makeLayerProperty(getRasterOpacityTransition());
case Property::RasterResamplingTransition:
return conversion::makeLayerProperty(getRasterResamplingTransition());
case Property::RasterSaturationTransition:
return conversion::makeLayerProperty(getRasterSaturationTransition());
}
return {};
}
optional<Error> RasterLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -1102,71 +1102,74 @@ TransitionOptions SymbolLayer::getTextTranslateAnchorTransition() const {
using namespace conversion;
namespace {
enum class Property {
IconColor,
IconHaloBlur,
IconHaloColor,
IconHaloWidth,
IconOpacity,
IconTranslate,
IconTranslateAnchor,
TextColor,
TextHaloBlur,
TextHaloColor,
TextHaloWidth,
TextOpacity,
TextTranslate,
TextTranslateAnchor,
IconColorTransition,
IconHaloBlurTransition,
IconHaloColorTransition,
IconHaloWidthTransition,
IconOpacityTransition,
IconTranslateTransition,
IconTranslateAnchorTransition,
TextColorTransition,
TextHaloBlurTransition,
TextHaloColorTransition,
TextHaloWidthTransition,
TextOpacityTransition,
TextTranslateTransition,
TextTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto paintProperties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>(
{{"icon-color", mbgl::underlying_type(Property::IconColor)},
{"icon-halo-blur", mbgl::underlying_type(Property::IconHaloBlur)},
{"icon-halo-color", mbgl::underlying_type(Property::IconHaloColor)},
{"icon-halo-width", mbgl::underlying_type(Property::IconHaloWidth)},
{"icon-opacity", mbgl::underlying_type(Property::IconOpacity)},
{"icon-translate", mbgl::underlying_type(Property::IconTranslate)},
{"icon-translate-anchor", mbgl::underlying_type(Property::IconTranslateAnchor)},
{"text-color", mbgl::underlying_type(Property::TextColor)},
{"text-halo-blur", mbgl::underlying_type(Property::TextHaloBlur)},
{"text-halo-color", mbgl::underlying_type(Property::TextHaloColor)},
{"text-halo-width", mbgl::underlying_type(Property::TextHaloWidth)},
{"text-opacity", mbgl::underlying_type(Property::TextOpacity)},
{"text-translate", mbgl::underlying_type(Property::TextTranslate)},
{"text-translate-anchor", mbgl::underlying_type(Property::TextTranslateAnchor)},
{"icon-color-transition", mbgl::underlying_type(Property::IconColorTransition)},
{"icon-halo-blur-transition", mbgl::underlying_type(Property::IconHaloBlurTransition)},
{"icon-halo-color-transition", mbgl::underlying_type(Property::IconHaloColorTransition)},
{"icon-halo-width-transition", mbgl::underlying_type(Property::IconHaloWidthTransition)},
{"icon-opacity-transition", mbgl::underlying_type(Property::IconOpacityTransition)},
{"icon-translate-transition", mbgl::underlying_type(Property::IconTranslateTransition)},
{"icon-translate-anchor-transition", mbgl::underlying_type(Property::IconTranslateAnchorTransition)},
{"text-color-transition", mbgl::underlying_type(Property::TextColorTransition)},
{"text-halo-blur-transition", mbgl::underlying_type(Property::TextHaloBlurTransition)},
{"text-halo-color-transition", mbgl::underlying_type(Property::TextHaloColorTransition)},
{"text-halo-width-transition", mbgl::underlying_type(Property::TextHaloWidthTransition)},
{"text-opacity-transition", mbgl::underlying_type(Property::TextOpacityTransition)},
{"text-translate-transition", mbgl::underlying_type(Property::TextTranslateTransition)},
{"text-translate-anchor-transition", mbgl::underlying_type(Property::TextTranslateAnchorTransition)}});
} // namespace
optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property {
IconColor,
IconHaloBlur,
IconHaloColor,
IconHaloWidth,
IconOpacity,
IconTranslate,
IconTranslateAnchor,
TextColor,
TextHaloBlur,
TextHaloColor,
TextHaloWidth,
TextOpacity,
TextTranslate,
TextTranslateAnchor,
IconColorTransition,
IconHaloBlurTransition,
IconHaloColorTransition,
IconHaloWidthTransition,
IconOpacityTransition,
IconTranslateTransition,
IconTranslateAnchorTransition,
TextColorTransition,
TextHaloBlurTransition,
TextHaloColorTransition,
TextHaloWidthTransition,
TextOpacityTransition,
TextTranslateTransition,
TextTranslateAnchorTransition,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "icon-color", mbgl::underlying_type(Property::IconColor) },
{ "icon-halo-blur", mbgl::underlying_type(Property::IconHaloBlur) },
{ "icon-halo-color", mbgl::underlying_type(Property::IconHaloColor) },
{ "icon-halo-width", mbgl::underlying_type(Property::IconHaloWidth) },
{ "icon-opacity", mbgl::underlying_type(Property::IconOpacity) },
{ "icon-translate", mbgl::underlying_type(Property::IconTranslate) },
{ "icon-translate-anchor", mbgl::underlying_type(Property::IconTranslateAnchor) },
{ "text-color", mbgl::underlying_type(Property::TextColor) },
{ "text-halo-blur", mbgl::underlying_type(Property::TextHaloBlur) },
{ "text-halo-color", mbgl::underlying_type(Property::TextHaloColor) },
{ "text-halo-width", mbgl::underlying_type(Property::TextHaloWidth) },
{ "text-opacity", mbgl::underlying_type(Property::TextOpacity) },
{ "text-translate", mbgl::underlying_type(Property::TextTranslate) },
{ "text-translate-anchor", mbgl::underlying_type(Property::TextTranslateAnchor) },
{ "icon-color-transition", mbgl::underlying_type(Property::IconColorTransition) },
{ "icon-halo-blur-transition", mbgl::underlying_type(Property::IconHaloBlurTransition) },
{ "icon-halo-color-transition", mbgl::underlying_type(Property::IconHaloColorTransition) },
{ "icon-halo-width-transition", mbgl::underlying_type(Property::IconHaloWidthTransition) },
{ "icon-opacity-transition", mbgl::underlying_type(Property::IconOpacityTransition) },
{ "icon-translate-transition", mbgl::underlying_type(Property::IconTranslateTransition) },
{ "icon-translate-anchor-transition", mbgl::underlying_type(Property::IconTranslateAnchorTransition) },
{ "text-color-transition", mbgl::underlying_type(Property::TextColorTransition) },
{ "text-halo-blur-transition", mbgl::underlying_type(Property::TextHaloBlurTransition) },
{ "text-halo-color-transition", mbgl::underlying_type(Property::TextHaloColorTransition) },
{ "text-halo-width-transition", mbgl::underlying_type(Property::TextHaloWidthTransition) },
{ "text-opacity-transition", mbgl::underlying_type(Property::TextOpacityTransition) },
{ "text-translate-transition", mbgl::underlying_type(Property::TextTranslateTransition) },
{ "text-translate-anchor-transition", mbgl::underlying_type(Property::TextTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());
if (it == properties.end()) {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return Error { "layer doesn't support this property" };
}
@@ -1360,6 +1363,73 @@ optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Con
return Error { "layer doesn't support this property" };
}
LayerProperty SymbolLayer::getPaintProperty(const std::string& name) const {
const auto it = paintProperties.find(name.c_str());
if (it == paintProperties.end()) {
return {};
}
switch (static_cast<Property>(it->second)) {
case Property::IconColor:
return conversion::makeLayerProperty(getIconColor());
case Property::IconHaloBlur:
return conversion::makeLayerProperty(getIconHaloBlur());
case Property::IconHaloColor:
return conversion::makeLayerProperty(getIconHaloColor());
case Property::IconHaloWidth:
return conversion::makeLayerProperty(getIconHaloWidth());
case Property::IconOpacity:
return conversion::makeLayerProperty(getIconOpacity());
case Property::IconTranslate:
return conversion::makeLayerProperty(getIconTranslate());
case Property::IconTranslateAnchor:
return conversion::makeLayerProperty(getIconTranslateAnchor());
case Property::TextColor:
return conversion::makeLayerProperty(getTextColor());
case Property::TextHaloBlur:
return conversion::makeLayerProperty(getTextHaloBlur());
case Property::TextHaloColor:
return conversion::makeLayerProperty(getTextHaloColor());
case Property::TextHaloWidth:
return conversion::makeLayerProperty(getTextHaloWidth());
case Property::TextOpacity:
return conversion::makeLayerProperty(getTextOpacity());
case Property::TextTranslate:
return conversion::makeLayerProperty(getTextTranslate());
case Property::TextTranslateAnchor:
return conversion::makeLayerProperty(getTextTranslateAnchor());
case Property::IconColorTransition:
return conversion::makeLayerProperty(getIconColorTransition());
case Property::IconHaloBlurTransition:
return conversion::makeLayerProperty(getIconHaloBlurTransition());
case Property::IconHaloColorTransition:
return conversion::makeLayerProperty(getIconHaloColorTransition());
case Property::IconHaloWidthTransition:
return conversion::makeLayerProperty(getIconHaloWidthTransition());
case Property::IconOpacityTransition:
return conversion::makeLayerProperty(getIconOpacityTransition());
case Property::IconTranslateTransition:
return conversion::makeLayerProperty(getIconTranslateTransition());
case Property::IconTranslateAnchorTransition:
return conversion::makeLayerProperty(getIconTranslateAnchorTransition());
case Property::TextColorTransition:
return conversion::makeLayerProperty(getTextColorTransition());
case Property::TextHaloBlurTransition:
return conversion::makeLayerProperty(getTextHaloBlurTransition());
case Property::TextHaloColorTransition:
return conversion::makeLayerProperty(getTextHaloColorTransition());
case Property::TextHaloWidthTransition:
return conversion::makeLayerProperty(getTextHaloWidthTransition());
case Property::TextOpacityTransition:
return conversion::makeLayerProperty(getTextOpacityTransition());
case Property::TextTranslateTransition:
return conversion::makeLayerProperty(getTextTranslateTransition());
case Property::TextTranslateAnchorTransition:
return conversion::makeLayerProperty(getTextTranslateAnchorTransition());
}
return {};
}
optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
if (name == "visibility") {
return Layer::setVisibility(value);

View File

@@ -45,10 +45,7 @@ std::array<double, 4> Color::toArray() const {
}
mbgl::Value Color::toObject() const {
return mapbox::base::ValueObject{{"r", double(r)},
{"g", double(g)},
{"b", double(b)},
{"a", double(a)}};
return mapbox::base::ValueObject{{"r", double(r)}, {"g", double(g)}, {"b", double(b)}, {"a", double(a)}};
}
} // namespace mbgl