diff options
Diffstat (limited to 'include/mbgl/style')
23 files changed, 1419 insertions, 0 deletions
diff --git a/include/mbgl/style/applied_class_properties.hpp b/include/mbgl/style/applied_class_properties.hpp new file mode 100644 index 0000000000..827f15a2a1 --- /dev/null +++ b/include/mbgl/style/applied_class_properties.hpp @@ -0,0 +1,39 @@ +#ifndef MBGL_STYLE_APPLIED_CLASS_PROPERTIES +#define MBGL_STYLE_APPLIED_CLASS_PROPERTIES + +#include <mbgl/style/property_value.hpp> +#include <mbgl/style/class_dictionary.hpp> +#include <mbgl/util/time.hpp> + +#include <list> + +namespace mbgl { + +class AppliedClassProperty { +public: + AppliedClassProperty(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value); + +public: + const ClassID name; + const timestamp begin; + const timestamp end; + const PropertyValue value; +}; + + +class AppliedClassProperties { +public: + std::list<AppliedClassProperty> properties; + +public: + // Returns thie ID of the most recent + ClassID mostRecent() const; + void add(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value); + bool hasTransitions() const; + void cleanup(timestamp now); + bool empty() const; +}; + +} + +#endif diff --git a/include/mbgl/style/class_dictionary.hpp b/include/mbgl/style/class_dictionary.hpp new file mode 100644 index 0000000000..c7f9c6a284 --- /dev/null +++ b/include/mbgl/style/class_dictionary.hpp @@ -0,0 +1,32 @@ +#ifndef MBGL_STYLE_CLASS_DICTIONARY +#define MBGL_STYLE_CLASS_DICTIONARY + +#include <cstdint> +#include <string> +#include <unordered_map> + +namespace mbgl { + +enum class ClassID : uint32_t { + Fallback = 0, // These values are from the fallback properties + Default = 1, // These values are from the default style for a layer + Named = 2 // These values (and all subsequent IDs) are from a named style from the layer +}; + +class ClassDictionary { +public: + // Returns an ID for a class name. If the class name does not yet have an ID, one is + // auto-generated and stored for future reference. + static ClassID Lookup(const std::string &class_name); + + // Returns either Fallback, Default or Named, depending on the type of the class id. + static ClassID Normalize(ClassID id); + +private: + static std::unordered_map<std::string, ClassID> store; + static uint32_t offset; +}; + +} + +#endif diff --git a/include/mbgl/style/class_properties.hpp b/include/mbgl/style/class_properties.hpp new file mode 100644 index 0000000000..84b6f483bd --- /dev/null +++ b/include/mbgl/style/class_properties.hpp @@ -0,0 +1,43 @@ +#ifndef MBGL_STYLE_CLASS_PROPERTIES +#define MBGL_STYLE_CLASS_PROPERTIES + +#include <mbgl/style/property_key.hpp> +#include <mbgl/style/property_value.hpp> +#include <mbgl/style/property_transition.hpp> + +#include <map> + +namespace mbgl { + +class ClassProperties { +public: + inline ClassProperties() {} + inline ClassProperties(ClassProperties &&properties) + : properties(std::move(properties.properties)) {} + + inline void set(PropertyKey key, const PropertyValue &value) { + properties.emplace(key, value); + } + + inline void set(PropertyKey key, const PropertyTransition &transition) { + transitions.emplace(key, transition); + } + + const PropertyTransition &getTransition(PropertyKey key, const PropertyTransition &defaultTransition) const; + + // Route-through iterable interface so that you can iterate on the object as is. + inline std::map<PropertyKey, PropertyValue>::const_iterator begin() const { + return properties.begin(); + } + inline std::map<PropertyKey, PropertyValue>::const_iterator end() const { + return properties.end(); + } + +public: + std::map<PropertyKey, PropertyValue> properties; + std::map<PropertyKey, PropertyTransition> transitions; +}; + +} + +#endif diff --git a/include/mbgl/style/filter_comparison.hpp b/include/mbgl/style/filter_comparison.hpp new file mode 100644 index 0000000000..bf48744f1e --- /dev/null +++ b/include/mbgl/style/filter_comparison.hpp @@ -0,0 +1,65 @@ +#ifndef MBGL_STYLE_FILTER_COMPARISON +#define MBGL_STYLE_FILTER_COMPARISON + +#include <mbgl/style/value.hpp> + +#include <vector> +#include <string> +#include <iosfwd> + +namespace mbgl { + +class FilterComparison { +public: + enum class Operator : uint8_t { + Equal, + NotEqual, + Greater, + GreaterEqual, + Less, + LessEqual, + In, + NotIn + }; + + class Instance { + public: + Instance(Operator op, std::vector<Value> &&values) + : op(op), values(values) {} + + bool compare(const std::vector<Value> &property_values) const; + + private: + Operator op = Operator::Equal; + std::vector<Value> values; + + friend std::ostream& operator <<(std::ostream &, const Instance &); + }; + +public: + FilterComparison(const std::string &field) : field(field) {}; + + const std::string &getField() const; + template <typename Extractor> inline bool compare(const Extractor &extractor) const; + + template <typename ...Args> + inline void add(Args&& ...args) { + instances.emplace_back(::std::forward<Args>(args)...); + } + +private: + std::string field; + std::vector<Instance> instances; + + friend std::ostream& operator <<(std::ostream &, const FilterComparison &); +}; + +std::ostream& operator <<(std::ostream &s, const FilterComparison &comparison); +std::ostream& operator <<(std::ostream &s, const FilterComparison::Instance &instance); + + +FilterComparison::Operator parseFilterComparisonOperator(const std::string &op); + +} + +#endif diff --git a/include/mbgl/style/filter_comparison_private.hpp b/include/mbgl/style/filter_comparison_private.hpp new file mode 100644 index 0000000000..6486832424 --- /dev/null +++ b/include/mbgl/style/filter_comparison_private.hpp @@ -0,0 +1,23 @@ +#ifndef MBGL_STYLE_FILTER_COMPARISON_PRIVATE +#define MBGL_STYLE_FILTER_COMPARISON_PRIVATE + +#include "filter_comparison.hpp" + +namespace mbgl { + +template <typename Extractor> +inline bool FilterComparison::compare(const Extractor &extractor) const { + const std::vector<Value> values = extractor.getValues(field); + + // All instances are ANDed together. + for (const Instance &instance : instances) { + if (!instance.compare(values)) { + return false; + } + } + return true; +} + +} + +#endif diff --git a/include/mbgl/style/filter_expression.hpp b/include/mbgl/style/filter_expression.hpp new file mode 100644 index 0000000000..2a6a2927e7 --- /dev/null +++ b/include/mbgl/style/filter_expression.hpp @@ -0,0 +1,54 @@ +#ifndef MBGL_STYLE_FILTER_EXPRESSION +#define MBGL_STYLE_FILTER_EXPRESSION + +#include <mbgl/style/filter_comparison.hpp> +#include <mbgl/util/recursive_wrapper.hpp> + +#include <iosfwd> + +namespace mbgl { + +class FilterExpression { +public: + typedef util::recursive_wrapper<FilterExpression> Wrapper; + + enum class Operator : uint8_t { + And, + Or, + Xor, + Nor + }; + + enum class GeometryType : uint8_t { + Any, + Point, + LineString, + Polygon + }; + +public: + FilterExpression() = default; + FilterExpression(Operator op) : op(op) {}; + + bool empty() const; + + template <typename Extractor> bool compare(const Extractor &extractor) const; + void add(const FilterComparison &comparison); + void add(const FilterExpression &expression); + void setGeometryType(GeometryType g); + +private: + Operator op = Operator::And; + GeometryType type = GeometryType::Any; + std::vector<FilterComparison> comparisons; + std::vector<FilterExpression::Wrapper> expressions; + + friend std::ostream& operator <<(std::ostream &, const FilterExpression &); +}; + +std::ostream& operator <<(std::ostream &s, const FilterExpression &expression); + +FilterExpression::GeometryType parseGeometryType(const std::string &geometry); +} + +#endif diff --git a/include/mbgl/style/filter_expression_private.hpp b/include/mbgl/style/filter_expression_private.hpp new file mode 100644 index 0000000000..9379d250ba --- /dev/null +++ b/include/mbgl/style/filter_expression_private.hpp @@ -0,0 +1,75 @@ +#ifndef MBGL_STYLE_FILTER_EXPRESSION_PRIVATE +#define MBGL_STYLE_FILTER_EXPRESSION_PRIVATE + +#include "filter_expression.hpp" +#include "filter_comparison_private.hpp" + +namespace mbgl { + +template <typename Extractor> +bool FilterExpression::compare(const Extractor &extractor) const { + if (type != GeometryType::Any && extractor.getType() != type && extractor.getType() != GeometryType::Any) { + return false; + } + + switch (op) { + case Operator::And: + for (const FilterComparison &comparison : comparisons) { + if (!comparison.compare(extractor)) { + return false; + } + } + for (const FilterExpression &expression: expressions) { + if (!expression.compare(extractor)) { + return false; + } + } + return true; + case Operator::Or: + for (const FilterComparison &comparison : comparisons) { + if (comparison.compare(extractor)) { + return true; + } + } + for (const FilterExpression &expression: expressions) { + if (expression.compare(extractor)) { + return true; + } + } + return false; + case Operator::Xor: { + int count = 0; + for (const FilterComparison &comparison : comparisons) { + count += comparison.compare(extractor); + if (count > 1) { + return false; + } + } + for (const FilterExpression &expression: expressions) { + count += expression.compare(extractor); + if (count > 1) { + return false; + } + } + return count == 1; + } + case Operator::Nor: + for (const FilterComparison &comparison : comparisons) { + if (comparison.compare(extractor)) { + return false; + } + } + for (const FilterExpression &expression: expressions) { + if (expression.compare(extractor)) { + return false; + } + } + return true; + default: + return true; + } +} + +} + +#endif diff --git a/include/mbgl/style/function_properties.hpp b/include/mbgl/style/function_properties.hpp new file mode 100644 index 0000000000..74ac80f83c --- /dev/null +++ b/include/mbgl/style/function_properties.hpp @@ -0,0 +1,79 @@ +#ifndef MBGL_STYLE_FUNCTION_PROPERTIES +#define MBGL_STYLE_FUNCTION_PROPERTIES + +#include <mbgl/util/variant.hpp> + +#include <vector> + +namespace mbgl { + +template <typename T> +struct ConstantFunction { + inline ConstantFunction(const T &value) : value(value) {} + inline T evaluate(float) const { return value; } + +private: + const T value; +}; + +template <typename T> +struct LinearFunction { + inline LinearFunction(const T &value, float z_base, float slope, const T &min, const T &max) + : value(value), min(min), max(max), z_base(z_base), slope(slope) {} + T evaluate(float z) const; + +private: + const T value, min, max; + const float z_base, slope; +}; + +template <typename T> +struct ExponentialFunction { + inline ExponentialFunction(const T &value, float z_base, float exp_base, float slope, const T &min, + const T &max) + : value(value), min(min), max(max), z_base(z_base), exp_base(exp_base), slope(slope) {} + T evaluate(float z) const; + +private: + const T value, min, max; + const float z_base, exp_base, slope; +}; + +template <typename T> +struct StopsFunction { + inline StopsFunction(const std::vector<std::pair<float, T>> &values) : values(values) {} + T evaluate(float z) const; + +private: + const std::vector<std::pair<float, T>> values; +}; + +template <typename T> +using Function = util::variant< + std::false_type, + ConstantFunction<T>, + LinearFunction<T>, + ExponentialFunction<T>, + StopsFunction<T> +>; + +template <typename T> +struct FunctionEvaluator { + typedef T result_type; + inline FunctionEvaluator(float z) : z(z) {} + + inline result_type operator()(const std::false_type &) { + return result_type(); + } + + template <template <typename> class Fn> + inline result_type operator()(const Fn<T>& fn) { + return fn.evaluate(z); + } +private: + float z; +}; + +} + +#endif diff --git a/include/mbgl/style/property_fallback.hpp b/include/mbgl/style/property_fallback.hpp new file mode 100644 index 0000000000..5c5eae0cd6 --- /dev/null +++ b/include/mbgl/style/property_fallback.hpp @@ -0,0 +1,29 @@ +#ifndef MBGL_STYLE_PROPERTY_FALLBACK +#define MBGL_STYLE_PROPERTY_FALLBACK + +#include <mbgl/style/property_key.hpp> +#include <mbgl/style/property_value.hpp> + +#include <map> + +namespace mbgl { + +class PropertyFallbackValue { +public: + static const PropertyValue &Get(PropertyKey key) { + auto it = properties.find(key); + if (it != properties.end()) { + return it->second; + } else { + return defaultProperty; + } + } + +private: + static const std::map<PropertyKey, PropertyValue> properties; + static const PropertyValue defaultProperty; +}; + +} + +#endif diff --git a/include/mbgl/style/property_key.hpp b/include/mbgl/style/property_key.hpp new file mode 100644 index 0000000000..d9005f2f4a --- /dev/null +++ b/include/mbgl/style/property_key.hpp @@ -0,0 +1,57 @@ +#ifndef MBGL_STYLE_PROPERTY_KEY +#define MBGL_STYLE_PROPERTY_KEY + +namespace mbgl { + +enum class PropertyKey { + FillAntialias, + FillOpacity, + FillColor, + FillOutlineColor, + FillTranslate, // for transitions only + FillTranslateX, + FillTranslateY, + FillTranslateAnchor, + FillImage, + + LineOpacity, + LineColor, + LineTranslate, // for transitions only + LineTranslateX, + LineTranslateY, + LineTranslateAnchor, + LineWidth, + LineOffset, + LineBlur, + LineDashArray, // for transitions only + LineDashLand, + LineDashGap, + LineImage, + + IconOpacity, + IconRotate, + IconRotateAnchor, + + TextOpacity, + TextSize, + TextColor, + TextHaloColor, + TextHaloWidth, + TextHaloBlur, + + CompositeOpacity, + + RasterOpacity, + RasterSpin, + RasterBrightnessLow, + RasterBrightnessHigh, + RasterSaturation, + RasterContrast, + RasterFade, + + BackgroundColor +}; + +} + +#endif diff --git a/include/mbgl/style/property_transition.hpp b/include/mbgl/style/property_transition.hpp new file mode 100644 index 0000000000..07b7cfe288 --- /dev/null +++ b/include/mbgl/style/property_transition.hpp @@ -0,0 +1,15 @@ +#ifndef MBGL_STYLE_PROPERTY_TRANSITION +#define MBGL_STYLE_PROPERTY_TRANSITION + +#include <cstdint> + +namespace mbgl { + +struct PropertyTransition { + uint16_t duration = 0; + uint16_t delay = 0; +}; + +} + +#endif
\ No newline at end of file diff --git a/include/mbgl/style/property_value.hpp b/include/mbgl/style/property_value.hpp new file mode 100644 index 0000000000..4d148dc029 --- /dev/null +++ b/include/mbgl/style/property_value.hpp @@ -0,0 +1,21 @@ +#ifndef MBGL_STYLE_PROPERTY_VALUE +#define MBGL_STYLE_PROPERTY_VALUE + +#include <mbgl/util/variant.hpp> +#include <mbgl/style/function_properties.hpp> +#include <mbgl/style/types.hpp> + +namespace mbgl { + +typedef util::variant< + std::string, + TranslateAnchorType, + RotateAnchorType, + Function<bool>, + Function<float>, + Function<Color> +> PropertyValue; + +} + +#endif diff --git a/include/mbgl/style/rasterize_properties.hpp b/include/mbgl/style/rasterize_properties.hpp new file mode 100644 index 0000000000..aea90dfbdd --- /dev/null +++ b/include/mbgl/style/rasterize_properties.hpp @@ -0,0 +1,38 @@ +#ifndef MBGL_STYLE_RASTERIZE_PROPERTIES +#define MBGL_STYLE_RASTERIZE_PROPERTIES + +#include <mbgl/style/function_properties.hpp> + +namespace mbgl { + +// The calculated properties for a layer in a tile. +class RasterizedProperties { +public: + float buffer = 1.0f / 32.0f; + uint16_t size = 256; + uint8_t blur = 0; +}; + +class RasterizeProperties { +public: + Function<bool> enabled = ConstantFunction<bool>(false); + Function<float> buffer = ConstantFunction<float>(1.0f / 32.0f); + Function<float> size = ConstantFunction<float>(256); + Function<float> blur = ConstantFunction<float>(0); + + inline bool isEnabled(const int8_t z) const { + return util::apply_visitor(FunctionEvaluator<bool>(z), enabled); + } + + inline RasterizedProperties get(const int8_t z) const { + RasterizedProperties properties; + properties.buffer = util::apply_visitor(FunctionEvaluator<float>(z), buffer); + properties.size = util::apply_visitor(FunctionEvaluator<float>(z), size); + properties.blur = util::apply_visitor(FunctionEvaluator<float>(z), blur); + return properties; + } +}; + +} + +#endif diff --git a/include/mbgl/style/style.hpp b/include/mbgl/style/style.hpp new file mode 100644 index 0000000000..6aab71a4c6 --- /dev/null +++ b/include/mbgl/style/style.hpp @@ -0,0 +1,68 @@ +#ifndef MBGL_STYLE_STYLE +#define MBGL_STYLE_STYLE + +#include <mbgl/style/property_transition.hpp> +#include <mbgl/style/style_source.hpp> + +#include <mbgl/util/time.hpp> +#include <mbgl/util/uv.hpp> + +#include <cstdint> +#include <map> +#include <string> +#include <unordered_map> +#include <vector> +#include <set> +#include <memory> + +namespace mbgl { + +class Sprite; +class StyleLayer; +class StyleLayerGroup; +struct BackgroundProperties; + +class Style { +public: + struct exception : std::runtime_error { exception(const char *msg) : std::runtime_error(msg) {} }; + +public: + Style(); + + void loadJSON(const uint8_t *const data); + + size_t layerCount() const; + void updateProperties(float z, timestamp t); + + void setDefaultTransitionDuration(uint16_t duration_milliseconds = 0); + + void setAppliedClasses(const std::vector<std::string> &classes); + const std::vector<std::string> &getAppliedClasses() const; + void toggleClass(const std::string &name); + + // Updates the styling information to reflect the current array + // of applied classes. + void updateClasses(); + + bool hasTransitions() const; + + const BackgroundProperties &getBackgroundProperties() const; + +public: + std::shared_ptr<Sprite> sprite; + std::shared_ptr<StyleLayerGroup> layers; + std::vector<std::string> appliedClasses; + std::string sprite_url; + std::string glyph_url; + + +private: + PropertyTransition defaultTransition; + bool initial_render_complete = false; + + mutable uv::rwlock mtx; +}; + +} + +#endif diff --git a/include/mbgl/style/style_bucket.hpp b/include/mbgl/style/style_bucket.hpp new file mode 100644 index 0000000000..62f072d9cd --- /dev/null +++ b/include/mbgl/style/style_bucket.hpp @@ -0,0 +1,88 @@ +#ifndef MBGL_STYLE_STYLE_BUCKET +#define MBGL_STYLE_STYLE_BUCKET + +#include <mbgl/style/types.hpp> +#include <mbgl/style/filter_expression.hpp> +#include <mbgl/style/style_source.hpp> +#include <mbgl/util/vec.hpp> +#include <mbgl/util/variant.hpp> + +#include <memory> +#include <forward_list> + +namespace mbgl { + +class Source; + +class StyleBucketFill { +public: + WindingType winding = WindingType::Default; +}; + +class StyleBucketLine { +public: + CapType cap = CapType::Default; + JoinType join = JoinType::Default; + float miter_limit = 2.0f; + float round_limit = 1.0f; +}; + +class StyleBucketIcon { +public: + uint16_t size = 16; + vec2<float> translate {0, 0}; + TranslateAnchorType translate_anchor = TranslateAnchorType::Default; + std::string icon; + float spacing = 0.0f; + float padding = 2.0f; +}; + +class StyleBucketText { +public: + std::string field; + TextPathType path = TextPathType::Default; + TextTransformType transform = TextTransformType::Default; + std::string font; + float max_size = 16.0f; + float max_width = 15.0f * 24; + float line_height = 1.2f * 24; + float letter_spacing = 0.0f; + float alignment = 0.5f; + float vertical_alignment = 0.5; + vec2<float> translate {0, 0}; + TranslateAnchorType translate_anchor = TranslateAnchorType::Default; + float max_angle_delta = M_PI; + float min_distance = 250.0f; + float rotate = 0.0f; // what is this? + float padding = 2.0f; + float slant = 0.0f; + bool always_visible = false; +}; + +class StyleBucketRaster { +public: +}; + +typedef util::variant<StyleBucketFill, StyleBucketLine, StyleBucketIcon, + StyleBucketText, StyleBucketRaster, + std::false_type> StyleBucketRender; + + +class StyleBucket { +public: + typedef std::shared_ptr<StyleBucket> Ptr; + + StyleBucket(StyleLayerType type); + + std::string name; + std::shared_ptr<StyleSource> style_source; + std::string source_layer; + FilterExpression filter; + StyleBucketRender render = std::false_type(); +}; + + + +}; + +#endif diff --git a/include/mbgl/style/style_layer.hpp b/include/mbgl/style/style_layer.hpp new file mode 100644 index 0000000000..14d60ed9b6 --- /dev/null +++ b/include/mbgl/style/style_layer.hpp @@ -0,0 +1,94 @@ +#ifndef MBGL_STYLE_STYLE_LAYER +#define MBGL_STYLE_STYLE_LAYER + +#include <mbgl/style/class_dictionary.hpp> +#include <mbgl/style/class_properties.hpp> +#include <mbgl/style/style_properties.hpp> +#include <mbgl/style/rasterize_properties.hpp> +#include <mbgl/style/applied_class_properties.hpp> + +#include <vector> +#include <memory> +#include <string> +#include <map> +#include <set> + +namespace mbgl { + +class StyleBucket; +class StyleLayerGroup; + +class StyleLayer { +public: + StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles, + std::unique_ptr<const RasterizeProperties> &&rasterize); + + template <typename T> const T &getProperties() { + if (properties.is<T>()) { + return properties.get<T>(); + } else { + return defaultStyleProperties<T>(); + } + } + + // Determines whether this layer is the background layer. + bool isBackground() const; + + // Updates the StyleProperties information in this layer by evaluating all + // pending transitions and applied classes in order. + void updateProperties(float z, timestamp now); + + // Sets the list of classes and creates transitions to the currently applied values. + void setClasses(const std::vector<std::string> &class_names, timestamp now, + const PropertyTransition &defaultTransition); + + bool hasTransitions() const; + +private: + // Applies all properties from a class, if they haven't been applied already. + void applyClassProperties(ClassID class_id, std::set<PropertyKey> &already_applied, + timestamp now, const PropertyTransition &defaultTransition); + + // Sets the properties of this object by evaluating all pending transitions and + // aplied classes in order. + template <typename T> void applyStyleProperties(float z, timestamp now); + template <typename T> void applyStyleProperty(PropertyKey key, T &, float z, timestamp now); + + // Removes all expired style transitions. + void cleanupAppliedStyleProperties(timestamp now); + +public: + // The name of this layer. + const std::string id; + + StyleLayerType type = StyleLayerType::Unknown; + + // Bucket information, telling the renderer how to generate the geometries + // for this layer (feature property filters, tessellation instructions, ...). + std::shared_ptr<StyleBucket> bucket; + + // Contains all style classes that can be applied to this layer. + const std::map<ClassID, ClassProperties> styles; + +private: + // For every property, stores a list of applied property values, with + // optional transition times. + std::map<PropertyKey, AppliedClassProperties> appliedStyle; + +public: + // Stores the evaluated, and cascaded styling information, specific to this + // layer's type. + StyleProperties properties; + + // Rasterization properties are used for prerendering the tile to a bitmap, + // which is then used as a raster image instead of rendering this layer + // directly in every frame. + const std::unique_ptr<const RasterizeProperties> rasterize; + + // Child layer array (if this layer has child layers). + std::shared_ptr<StyleLayerGroup> layers; +}; + +} + +#endif diff --git a/include/mbgl/style/style_layer_group.hpp b/include/mbgl/style/style_layer_group.hpp new file mode 100644 index 0000000000..983dd136f0 --- /dev/null +++ b/include/mbgl/style/style_layer_group.hpp @@ -0,0 +1,23 @@ +#ifndef MBGL_STYLE_STYLE_LAYER_GROUP +#define MBGL_STYLE_STYLE_LAYER_GROUP + +#include <mbgl/style/style_layer.hpp> + +#include <vector> + +namespace mbgl { + +class StyleLayerGroup { +public: + void setClasses(const std::vector<std::string> &class_names, timestamp now, + const PropertyTransition &defaultTransition); + void updateProperties(float z, timestamp t); + + bool hasTransitions() const; +public: + std::vector<std::shared_ptr<StyleLayer>> layers; +}; + +} + +#endif diff --git a/include/mbgl/style/style_parser.hpp b/include/mbgl/style/style_parser.hpp new file mode 100644 index 0000000000..431e3af8db --- /dev/null +++ b/include/mbgl/style/style_parser.hpp @@ -0,0 +1,119 @@ +#ifndef MBGL_STYLE_STYLE_PARSER +#define MBGL_STYLE_STYLE_PARSER + +#include <rapidjson/document.h> +#include <mbgl/style/style.hpp> +#include <mbgl/style/style_source.hpp> +#include <mbgl/style/filter_expression.hpp> +#include <mbgl/style/class_properties.hpp> +#include <mbgl/style/rasterize_properties.hpp> +#include <mbgl/style/style_bucket.hpp> + +#include <unordered_map> +#include <forward_list> +#include <tuple> + +namespace mbgl { + +enum class ClassID : uint32_t; + +class StyleLayer; +class StyleLayerGroup; + +class StyleParser { +public: + using JSVal = const rapidjson::Value&; + + StyleParser(); + + void parse(JSVal document); + + std::shared_ptr<StyleLayerGroup> getLayers() { + return root; + } + + std::string getSprite() const { + return sprite; + } + + std::string getGlyphURL() const { + return glyph_url; + } + +private: + void parseConstants(JSVal value); + JSVal replaceConstant(JSVal value); + + void parseSources(JSVal value); + + std::unique_ptr<StyleLayerGroup> createLayers(JSVal value); + std::shared_ptr<StyleLayer> createLayer(JSVal value); + void parseLayers(); + void parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair); + void parseStyles(JSVal value, std::map<ClassID, ClassProperties> &styles); + void parseStyle(JSVal, ClassProperties &properties); + std::unique_ptr<RasterizeProperties> parseRasterize(JSVal value); + void parseReference(JSVal value, std::shared_ptr<StyleLayer> &layer); + void parseBucket(JSVal value, std::shared_ptr<StyleLayer> &layer); + void parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer); + void parseSprite(JSVal value); + void parseGlyphURL(JSVal value); + + // Parses optional properties into a render bucket. + template<typename T> + bool parseRenderProperty(JSVal value, T &target, const char *name); + template <typename T, typename Parser> + bool parseRenderProperty(JSVal value, T &target, const char *name, Parser &parser); + + // Parses optional properties into style class properties. + template <typename T> + bool parseOptionalProperty(const char *property_name, PropertyKey key, ClassProperties &klass, JSVal value); + template <typename T> + bool parseOptionalProperty(const char *property_name, const std::vector<PropertyKey> &keys, ClassProperties &klass, JSVal value); + template <typename T> + bool parseOptionalProperty(const char *property_name, T &target, JSVal value); + template <typename T> + bool setProperty(JSVal value, const char *property_name, PropertyKey key, ClassProperties &klass); + template <typename T> + bool setProperty(JSVal value, const char *property_name, T &target); + + template <typename T> + std::tuple<bool, T> parseProperty(JSVal value, const char *property_name); + + template <typename T> + bool parseFunction(PropertyKey key, ClassProperties &klass, JSVal value); + template <typename T> + std::tuple<bool, Function<T>> parseFunction(JSVal value); + template <typename T> + T parseFunctionArgument(JSVal value); + + + FilterExpression parseFilter(JSVal, FilterExpression::Operator op); + FilterExpression parseFilter(JSVal); + Value parseValue(JSVal value); + std::vector<Value> parseValues(JSVal values); + +private: + std::unordered_map<std::string, const rapidjson::Value *> constants; + + std::unordered_map<std::string, const std::shared_ptr<StyleSource>> sources; + + // This stores the root layer. + std::shared_ptr<StyleLayerGroup> root; + + // This maps ids to Layer objects, with all items being at the root level. + std::unordered_map<std::string, std::pair<JSVal, std::shared_ptr<StyleLayer>>> layers; + + // Store a stack of layers we're parsing right now. This is to prevent reference cycles. + std::forward_list<StyleLayer *> stack; + + // Base URL of the sprite image. + std::string sprite; + + // URL template for glyph PBFs. + std::string glyph_url; +}; + +} + +#endif diff --git a/include/mbgl/style/style_properties.hpp b/include/mbgl/style/style_properties.hpp new file mode 100644 index 0000000000..c7606be254 --- /dev/null +++ b/include/mbgl/style/style_properties.hpp @@ -0,0 +1,116 @@ +#ifndef MBGL_STYLE_STYLE_PROPERTIES +#define MBGL_STYLE_STYLE_PROPERTIES + +#include <mbgl/util/variant.hpp> +#include <mbgl/style/types.hpp> +#include <mbgl/style/function_properties.hpp> + +#include <array> +#include <string> +#include <type_traits> +#include <memory> + +namespace mbgl { + +struct FillProperties { + FillProperties() {} + bool antialias = true; + float opacity = 1.0f; + Color fill_color = {{ 0, 0, 0, 1 }}; + Color stroke_color = {{ 0, 0, 0, -1 }}; + std::array<float, 2> translate = {{ 0, 0 }}; + TranslateAnchorType translateAnchor = TranslateAnchorType::Default; + std::string image; + + inline bool isVisible() const { + return opacity > 0 && (fill_color[3] > 0 || stroke_color[3] > 0); + } +}; + +struct LineProperties { + inline LineProperties() {} + float opacity = 1.0f; + Color color = {{ 0, 0, 0, 1 }}; + std::array<float, 2> translate = {{ 0, 0 }}; + TranslateAnchorType translateAnchor = TranslateAnchorType::Default; + float width = 0; + float offset = 0; + float blur = 0; + std::array<float, 2> dash_array = {{ 1, -1 }}; + std::string image; + + inline bool isVisible() const { + return opacity > 0 && color[3] > 0 && width > 0; + } +}; + +struct IconProperties { + inline IconProperties() {} + float opacity = 1.0f; + float rotate = 0.0f; + RotateAnchorType rotate_anchor = RotateAnchorType::Default; + + inline bool isVisible() const { + return opacity > 0; + } +}; + +struct TextProperties { + inline TextProperties() {} + float opacity = 1.0f; + float size = 12.0f; + Color color = {{ 0, 0, 0, 1 }}; + Color halo_color = {{ 1, 1, 1, 0.75 }}; + float halo_width = 0.25f; + float halo_blur = 1.0f; + + inline bool isVisible() const { + return opacity > 0 && (color[3] > 0 || halo_color[3] > 0) && size > 0; + } +}; + +struct CompositeProperties { + inline CompositeProperties() {} + float opacity = 1.0f; + + inline bool isVisible() const { + return opacity > 0; + } +}; + +struct RasterProperties { + inline RasterProperties() {} + float opacity = 1.0f; + float spin = 0.0f; + std::array<float, 2> brightness = {{ 0, 1 }}; + float saturation = 0.0f; + float contrast = 0.0f; + float fade = 0.0f; + + inline bool isVisible() const { + return opacity > 0; + } +}; + +struct BackgroundProperties { + inline BackgroundProperties() {} + Color color = {{ 1, 1, 1, 1 }}; +}; + +typedef util::variant< + FillProperties, + LineProperties, + IconProperties, + TextProperties, + CompositeProperties, + RasterProperties, + BackgroundProperties, + std::false_type +> StyleProperties; + +template <typename T> +const T &defaultStyleProperties(); + +} + +#endif diff --git a/include/mbgl/style/style_source.hpp b/include/mbgl/style/style_source.hpp new file mode 100644 index 0000000000..6b86c30907 --- /dev/null +++ b/include/mbgl/style/style_source.hpp @@ -0,0 +1,29 @@ +#ifndef MBGL_STYLE_STYLE_SOURCE +#define MBGL_STYLE_STYLE_SOURCE + +#include <mbgl/style/types.hpp> + +#include <memory> + +namespace mbgl { + +class Source; + +class StyleSource { +public: + const SourceType type; + const std::string url; + const uint32_t tile_size; + const int32_t min_zoom; + const int32_t max_zoom; + + bool enabled = false; + std::shared_ptr<Source> source; + + StyleSource(SourceType type = SourceType::Vector, const std::string &url = "", + uint32_t tile_size = 512, uint32_t min_zoom = 0, uint32_t max_zoom = 22) + : type(type), url(url), tile_size(tile_size), min_zoom(min_zoom), max_zoom(max_zoom) {} +}; +}; + +#endif diff --git a/include/mbgl/style/types.hpp b/include/mbgl/style/types.hpp new file mode 100644 index 0000000000..ca2061fa91 --- /dev/null +++ b/include/mbgl/style/types.hpp @@ -0,0 +1,160 @@ +#ifndef MBGL_STYLE_TYPES +#define MBGL_STYLE_TYPES + +#include <mbgl/util/enum.hpp> + +#include <string> +#include <array> + +namespace mbgl { + +// Stores a premultiplied color, with all four channels ranging from 0..1 +typedef std::array<float, 4> Color; + +enum class StyleLayerType : uint8_t { + Unknown, + Fill, + Line, + Icon, + Text, + Raster, + Composite, + Background +}; + +MBGL_DEFINE_ENUM_CLASS(StyleLayerTypeClass, StyleLayerType, { + { StyleLayerType::Unknown, "unknown" }, + { StyleLayerType::Fill, "fill" }, + { StyleLayerType::Line, "line" }, + { StyleLayerType::Icon, "icon" }, + { StyleLayerType::Text, "text" }, + { StyleLayerType::Raster, "raster" }, + { StyleLayerType::Composite, "composite" }, + { StyleLayerType::Background, "background" }, + { StyleLayerType(-1), "unknown" }, +}); + + +enum class WindingType : uint8_t { + EvenOdd, + NonZero, + Default = NonZero +}; + +enum class CapType : uint8_t { + None, + Round, + Butt, + Square, + Default = None +}; + +enum class JoinType : uint8_t { + None, + Miter, + Bevel, + Round, + Default = None +}; + +enum class TextPathType : uint8_t { + Horizontal, + Curve, + Default = Horizontal +}; + +enum class TextTransformType : uint8_t { + None, + Uppercase, + Lowercase, + Default = None +}; + +enum class TranslateAnchorType : uint8_t { + Map, + Viewport, + Default = Map +}; + +enum class RotateAnchorType : uint8_t { + Map, + Viewport, + Default = Viewport +}; + +enum class SourceType : uint8_t { + Vector, + Raster, + GeoJSON, + Video, + Default = Vector +}; + +inline WindingType parseWindingType(const std::string &type) { + if (type == "even-odd") return WindingType::EvenOdd; + if (type == "non-zero") return WindingType::NonZero; + return WindingType::Default; +} + +inline CapType parseCapType(const std::string &cap) { + if (cap == "round") return CapType::Round; + if (cap == "butt") return CapType::Butt; + if (cap == "square") return CapType::Square; + return CapType::None; +} + +inline JoinType parseJoinType(const std::string &join) { + if (join == "miter") return JoinType::Miter; + if (join == "bevel") return JoinType::Bevel; + if (join == "round") return JoinType::Round; + return JoinType::None; +} + +inline TextPathType parseTextPathType(const std::string &path) { + if (path == "horizontal") return TextPathType::Horizontal; + if (path == "curve") return TextPathType::Curve; + return TextPathType::Default; +} + +inline TextTransformType parseTextTransformType(const std::string& transform) { + if (transform == "uppercase") return TextTransformType::Uppercase; + if (transform == "lowercase") return TextTransformType::Lowercase; + return TextTransformType::Default; +}; + +inline TranslateAnchorType parseTranslateAnchorType(const std::string &anchor) { + if (anchor == "map") return TranslateAnchorType::Map; + if (anchor == "viewport") return TranslateAnchorType::Viewport; + return TranslateAnchorType::Default; +} + +inline RotateAnchorType parseRotateAnchorType(const std::string &anchor) { + if (anchor == "map") return RotateAnchorType::Map; + if (anchor == "viewport") return RotateAnchorType::Viewport; + return RotateAnchorType::Default; +} + +inline float parseAlignmentType(const std::string &alignment) { + if (alignment == "right") return 1.0f; + if (alignment == "left") return 0.0f; + return 0.5f; +} + +inline float parseVerticalAlignmentType(const std::string &alignment) { + if (alignment == "bottom") return 1.0f; + if (alignment == "top") return 0.0f; + return 0.5f; +} + +inline SourceType parseSourceType(const std::string &source) { + if (source == "vector") return SourceType::Vector; + if (source == "raster") return SourceType::Raster; + if (source == "geojson") return SourceType::GeoJSON; + if (source == "video") return SourceType::Video; + return SourceType::Default; +} + +} + +#endif + diff --git a/include/mbgl/style/value.hpp b/include/mbgl/style/value.hpp new file mode 100644 index 0000000000..5e6260e5a6 --- /dev/null +++ b/include/mbgl/style/value.hpp @@ -0,0 +1,43 @@ +#ifndef MBGL_STYLE_VALUE +#define MBGL_STYLE_VALUE + +#include <mbgl/util/variant.hpp> +#include <mbgl/util/pbf.hpp> + +#include <cstdlib> +#include <cerrno> + +namespace mbgl { + +typedef util::variant<bool, int64_t, uint64_t, double, std::string> Value; + +std::string toString(const Value &value); + +Value parseValue(pbf data); + +namespace util { +inline bool parseNumericString(const std::string &str, double &result) { + char *end = nullptr; + const char *begin = str.c_str(); + result = std::strtod(begin, &end); + while (*end != '\0' && isspace(*end)) end++; // eat whitespace after the end + return errno == 0 && end - begin == long(str.size()); +} +} + +template <typename T> +T toNumber(const Value &value) { + if (value.is<std::string>()) { + double val; + return util::parseNumericString(value.get<std::string>(), val) ? val : 0; + } + else if (value.is<bool>()) return value.get<bool>(); + else if (value.is<int64_t>()) return value.get<int64_t>(); + else if (value.is<uint64_t>()) return value.get<uint64_t>(); + else if (value.is<double>()) return value.get<double>(); + else return 0; +} + +} + +#endif diff --git a/include/mbgl/style/value_comparison.hpp b/include/mbgl/style/value_comparison.hpp new file mode 100644 index 0000000000..41c1d44123 --- /dev/null +++ b/include/mbgl/style/value_comparison.hpp @@ -0,0 +1,109 @@ +#ifndef MBGL_STYLE_VALUE_COMPARISON +#define MBGL_STYLE_VALUE_COMPARISON + +#include "value.hpp" +#include <cstdlib> +#include <cerrno> + +namespace mbgl { + +namespace util { + +namespace detail { + +template <typename Operator> +struct relaxed_operator_visitor { + typedef bool result_type; + + inline bool operator()(bool lhs, bool rhs) const { return Operator()(lhs, rhs); } + + template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type> + inline bool operator()(bool lhs, T rhs) const { return Operator()(T(lhs), rhs); } + + template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type> + inline bool operator()(T lhs, bool rhs) const { return Operator()(lhs, T(rhs)); } + + inline bool operator()(int64_t lhs, uint64_t rhs) const { + return lhs < 0 ? false : Operator()(uint64_t(lhs), rhs); + } + inline bool operator()(uint64_t lhs, int64_t rhs) const { + return rhs < 0 ? false : Operator()(lhs, uint64_t(rhs)); + } + + template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type> + inline bool operator()(const std::string &lhs, T rhs) const { + double value; + return parseNumericString(lhs, value) ? Operator()(value, double(rhs)) : false; + } + + template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type> + inline bool operator()(T lhs, const std::string &rhs) const { + double value; + return parseNumericString(rhs, value) ? Operator()(double(lhs), value) : false; + } + + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return Operator()(lhs, rhs); } +}; + +struct relaxed_equal_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs == rhs; } +}; + +struct relaxed_not_equal_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs != rhs; } +}; + +struct relaxed_greater_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs > rhs; } +}; + +struct relaxed_greater_equal_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs >= rhs; } +}; + +struct relaxed_less_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs < rhs; } +}; + +struct relaxed_less_equal_operator { + template <typename T0, typename T1> + inline bool operator()(T0 lhs, T1 rhs) const { return lhs <= rhs; } +}; + +} // end namespace detail + +inline bool relaxed_equal(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_equal_operator>(), lhs, rhs); +} + +inline bool relaxed_not_equal(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_not_equal_operator>(), lhs, rhs); +} + +inline bool relaxed_greater(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_greater_operator>(), lhs, rhs); +} + +inline bool relaxed_greater_equal(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_greater_equal_operator>(), lhs, rhs); +} + +inline bool relaxed_less(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_less_operator>(), lhs, rhs); +} + +inline bool relaxed_less_equal(Value const &lhs, Value const &rhs) { + return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_less_equal_operator>(), lhs, rhs); +} + +} + +} + +#endif |