merge text and icon buckets/styles

(we're not yet placing together!)

11 files changed, 226 insertions, 310 deletions

diff --git a/include/mbgl/map/tile_parser.hpp b/include/mbgl/map/tile_parser.hpp
index 1550350ed7..84505c1e05 100644
--- a/include/mbgl/map/tile_parser.hpp
+++ b/include/mbgl/map/tile_parser.hpp
@@ -21,9 +21,8 @@ class SpriteAtlas;
 class Style;
 class StyleBucket;
 class StyleBucketFill;
-class StyleBucketIcon;
 class StyleBucketLine;
-class StyleBucketText;
+class StyleBucketSymbol;
 class StyleLayerGroup;
 class VectorTileData;
 
@@ -40,18 +39,14 @@ public:
 
 private:
     bool obsolete() const;
-    void parseGlyphs();
     void parseStyleLayers(std::shared_ptr<StyleLayerGroup> group);
-    void addGlyph(uint64_t tileid, const std::string stackname, const std::u32string &string, const FontStack &fontStack, GlyphAtlas &glyphAtlas, GlyphPositions &face);
     std::unique_ptr<Bucket> createBucket(std::shared_ptr<StyleBucket> bucket_desc);
 
     std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
     std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
-    std::unique_ptr<Bucket> createIconBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketIcon &icon);
-    std::unique_ptr<Bucket> createTextBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketText &text);
+    std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);
 
-    template <class Bucket> void addBucketFeatures(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression &filter);
-    template <class Bucket, typename ...Args> void addBucketFeatures(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression &filter, Args&& ...args);
+    template <class Bucket> void addBucketGeometries(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression &filter);
 
 private:
     const VectorTile vector_data;
diff --git a/include/mbgl/renderer/icon_bucket.hpp b/include/mbgl/renderer/icon_bucket.hpp
deleted file mode 100644
index e3b311332d..0000000000
--- a/include/mbgl/renderer/icon_bucket.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef MBGL_RENDERER_ICONBUCKET
-#define MBGL_RENDERER_ICONBUCKET
-
-#include <mbgl/renderer/bucket.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/geometry/icon_buffer.hpp>
-#include <mbgl/style/style_bucket.hpp>
-
-#include <vector>
-#include <memory>
-
-#ifndef BUFFER_OFFSET
-#define BUFFER_OFFSET(i) ((char *)nullptr + (i))
-#endif
-
-namespace mbgl {
-
-class Style;
-class IconVertexBuffer;
-class BucketDescription;
-class IconShader;
-class DotShader;
-class SpriteAtlas;
-class VectorTileFeature;
-
-class IconBucket : public Bucket {
-public:
-    IconBucket(IconVertexBuffer& vertexBuffer,
-                const StyleBucketIcon& properties);
-
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
-    virtual bool hasData() const;
-
-    void addFeature(const VectorTileFeature &feature, SpriteAtlas &sprite_atlas);
-
-    void drawIcons(IconShader& shader);
-    void drawIcons(DotShader& shader);
-
-public:
-    const StyleBucketIcon &properties;
-
-private:
-
-    IconVertexBuffer& vertexBuffer;
-    VertexArrayObject array;
-
-    const size_t vertex_start;
-    size_t vertex_end = 0;
-};
-
-}
-
-#endif
diff --git a/include/mbgl/renderer/painter.hpp b/include/mbgl/renderer/painter.hpp
index dedb4dc120..b4023de167 100644
--- a/include/mbgl/renderer/painter.hpp
+++ b/include/mbgl/renderer/painter.hpp
@@ -38,8 +38,7 @@ class StyleSource;
 
 class FillBucket;
 class LineBucket;
-class IconBucket;
-class TextBucket;
+class SymbolBucket;
 class RasterBucket;
 
 struct FillProperties;
@@ -83,8 +82,7 @@ public:
     void renderFill(FillBucket& bucket, const FillProperties& properties, const Tile::ID& id, const mat4 &mat);
     void renderFill(FillBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
     void renderLine(LineBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
-    void renderIcon(IconBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
-    void renderText(TextBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
+    void renderSymbol(SymbolBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
     void renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
 
     void preparePrerender(PrerenderedTexture &texture);
@@ -119,7 +117,7 @@ public:
     bool needsAnimation() const;
 private:
     void setupShaders();
-    const mat4 &translatedMatrix(const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor = TranslateAnchorType::Default);
+    const mat4 &translatedMatrix(const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor = TranslateAnchorType::Map);
 
     void prepareTile(const Tile& tile);
 
diff --git a/include/mbgl/renderer/symbol_bucket.hpp b/include/mbgl/renderer/symbol_bucket.hpp
new file mode 100644
index 0000000000..a073856d2b
--- /dev/null
+++ b/include/mbgl/renderer/symbol_bucket.hpp
@@ -0,0 +1,82 @@
+#ifndef MBGL_RENDERER_SYMBOLBUCKET
+#define MBGL_RENDERER_SYMBOLBUCKET
+
+#include "bucket.hpp"
+#include <mbgl/geometry/vao.hpp>
+#include <mbgl/geometry/elements_buffer.hpp>
+#include <mbgl/map/vector_tile.hpp>
+#include <mbgl/text/types.hpp>
+#include <mbgl/text/glyph.hpp>
+#include <mbgl/style/style_bucket.hpp>
+
+#include <memory>
+#include <map>
+#include <vector>
+
+namespace mbgl {
+
+class Style;
+class TextVertexBuffer;
+class IconVertexBuffer;
+class TriangleElementsBuffer;
+class TextShader;
+class IconShader;
+class DotShader;
+class Placement;
+class SpriteAtlas;
+class GlyphAtlas;
+class GlyphStore;
+class FontStack;
+
+class SymbolBucket : public Bucket {
+    typedef ElementGroup triangle_group_type;
+
+public:
+    SymbolBucket(
+        TextVertexBuffer &textVertexBuffer,
+        IconVertexBuffer& iconVertexBuffer,
+        TriangleElementsBuffer &triangleElementsBuffer,
+        const StyleBucketSymbol &properties, Placement &placement);
+
+    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id);
+    virtual bool hasData() const;
+    virtual bool hasTextData() const;
+    virtual bool hasIconData() const;
+
+    void addFeatures(const VectorTileLayer &layer, const FilterExpression &filter,
+                     const Tile::ID &id, SpriteAtlas &spriteAtlas, GlyphAtlas &glyphAtlas,
+                     GlyphStore &glyphStore);
+
+    void addGlyphs(const PlacedGlyphs &glyphs, float placementZoom, PlacementRange placementRange,
+                   float zoom);
+
+
+    void drawGlyphs(TextShader &shader);
+    void drawIcons(IconShader& shader);
+    void drawIcons(DotShader& shader);
+
+private:
+    void addGlyph(uint64_t tileid, const std::string stackname, const std::u32string &string,
+                  const FontStack &fontStack, GlyphAtlas &glyphAtlas, GlyphPositions &face);
+    void addFeature(const pbf &geom_pbf, const GlyphPositions &face, const Shaping &shaping);
+
+public:
+    const StyleBucketSymbol &properties;
+
+private:
+    TextVertexBuffer& textVertexBuffer;
+    IconVertexBuffer& iconVertexBuffer;
+    TriangleElementsBuffer& triangleElementsBuffer;
+    Placement &placement;
+
+    const size_t text_vertex_start;
+    const size_t icon_vertex_start;
+    const size_t triangle_elements_start;
+    size_t icon_vertex_end = 0;
+    VertexArrayObject array;
+
+    std::vector<triangle_group_type> triangleGroups;
+};
+}
+
+#endif
diff --git a/include/mbgl/renderer/text_bucket.hpp b/include/mbgl/renderer/text_bucket.hpp
deleted file mode 100644
index cb4b8f2cda..0000000000
--- a/include/mbgl/renderer/text_bucket.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef MBGL_RENDERER_TEXTBUCKET
-#define MBGL_RENDERER_TEXTBUCKET
-
-#include "bucket.hpp"
-#include <mbgl/geometry/vao.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/map/vector_tile.hpp>
-#include <mbgl/text/types.hpp>
-#include <mbgl/text/glyph.hpp>
-#include <mbgl/style/style_bucket.hpp>
-
-#include <memory>
-#include <map>
-#include <vector>
-
-namespace mbgl {
-
-class Style;
-class TextVertexBuffer;
-class TriangleElementsBuffer;
-class TextShader;
-class Placement;
-struct pbf;
-
-class TextBucket : public Bucket {
-    typedef ElementGroup triangle_group_type;
-
-public:
-    TextBucket(
-        TextVertexBuffer &vertexBuffer,
-        TriangleElementsBuffer &triangleElementsBuffer,
-        const StyleBucketText &properties, Placement &placement);
-
-    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id);
-    virtual bool hasData() const;
-
-    void addGlyphs(const PlacedGlyphs &glyphs, float placementZoom,
-                   PlacementRange placementRange, float zoom);
-
-    void addFeature(const pbf &geometry,
-                    const GlyphPositions &face,
-                    const Shaping &shaping);
-
-    void drawGlyphs(TextShader &shader);
-
-public:
-    const StyleBucketText &properties;
-
-private:
-    TextVertexBuffer& vertexBuffer;
-    TriangleElementsBuffer& triangleElementsBuffer;
-    Placement &placement;
-
-    const size_t vertex_start;
-    const size_t triangle_elements_start;
-
-    std::vector<triangle_group_type> triangleGroups;
-};
-}
-
-#endif
diff --git a/include/mbgl/style/property_key.hpp b/include/mbgl/style/property_key.hpp
index d5553ebf0d..68dc709597 100644
--- a/include/mbgl/style/property_key.hpp
+++ b/include/mbgl/style/property_key.hpp
@@ -35,6 +35,7 @@ enum class PropertyKey {
     IconHaloColor,
     IconHaloWidth,
     IconHaloBlur,
+    IconTranslate, // for transitions only
     IconTranslateX,
     IconTranslateY,
     IconTranslateAnchor,
@@ -45,6 +46,7 @@ enum class PropertyKey {
     TextHaloColor,
     TextHaloWidth,
     TextHaloBlur,
+    TextTranslate, // for transitions only
     TextTranslateX,
     TextTranslateY,
     TextTranslateAnchor,
diff --git a/include/mbgl/style/style_bucket.hpp b/include/mbgl/style/style_bucket.hpp
index 6948a96158..af76650e56 100644
--- a/include/mbgl/style/style_bucket.hpp
+++ b/include/mbgl/style/style_bucket.hpp
@@ -18,52 +18,27 @@ class Source;
 
 class StyleBucketFill {
 public:
-    WindingType winding = WindingType::Default;
+    WindingType winding = WindingType::NonZero;
 };
 
 class StyleBucketLine {
 public:
-    CapType cap = CapType::Default;
-    JoinType join = JoinType::Default;
+    CapType cap = CapType::Butt;
+    JoinType join = JoinType::Miter;
     float miter_limit = 2.0f;
     float round_limit = 1.0f;
 };
 
-class StyleBucketIcon {
+class StyleBucketSymbol {
 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 = 45.0f;
-    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 StyleBucketSymbol : util::noncopyable {
-public:
-    PlacementType placement = PlacementType::Default;
+    // Make movable only.
+    inline StyleBucketSymbol() = default;
+    inline StyleBucketSymbol(StyleBucketSymbol &&) = default;
+    inline StyleBucketSymbol& operator=(StyleBucketSymbol &&) = default;
+    inline StyleBucketSymbol(const StyleBucketSymbol &) = delete;
+    inline StyleBucketSymbol& operator=(const StyleBucketSymbol &) = delete;
+
+    PlacementType placement = PlacementType::Point;
     float min_distance = 250.0f;
 
     struct {
@@ -76,6 +51,7 @@ public:
         float padding = 2.0f;
         bool keep_upright = false;
         vec2<float> offset = {0, 0};
+        TranslateAnchorType translate_anchor = TranslateAnchorType::Map;
     } icon;
 
     struct {
@@ -96,6 +72,7 @@ public:
         bool keep_upright = true;
         TextTransformType transform = TextTransformType::None;
         vec2<float> offset = {0, 0};
+        TranslateAnchorType translate_anchor = TranslateAnchorType::Map;
         bool allow_overlap = false;
         bool ignore_placement = false;
         bool optional = false;
@@ -106,9 +83,8 @@ class StyleBucketRaster {
 public:
 };
 
-typedef util::variant<StyleBucketFill, StyleBucketLine, StyleBucketIcon,
-                      StyleBucketText, StyleBucketRaster,
-                      std::false_type> StyleBucketRender;
+typedef util::variant<StyleBucketFill, StyleBucketLine, StyleBucketSymbol,
+                      StyleBucketRaster, std::false_type> StyleBucketRender;
 
 
 class StyleBucket {
diff --git a/include/mbgl/style/style_parser.hpp b/include/mbgl/style/style_parser.hpp
index 431e3af8db..8b8dc74f21 100644
--- a/include/mbgl/style/style_parser.hpp
+++ b/include/mbgl/style/style_parser.hpp
@@ -62,8 +62,8 @@ private:
     // 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);
+    template <typename Parser, typename T>
+    bool parseRenderProperty(JSVal value, T &target, const char *name);
 
     // Parses optional properties into style class properties.
     template <typename T>
diff --git a/include/mbgl/style/style_properties.hpp b/include/mbgl/style/style_properties.hpp
index 9575347be3..35ea97781b 100644
--- a/include/mbgl/style/style_properties.hpp
+++ b/include/mbgl/style/style_properties.hpp
@@ -19,7 +19,7 @@ struct FillProperties {
     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;
+    TranslateAnchorType translateAnchor = TranslateAnchorType::Map;
     std::string image;
 
     inline bool isVisible() const {
@@ -32,7 +32,7 @@ struct LineProperties {
     float opacity = 1.0f;
     Color color = {{ 0, 0, 0, 1 }};
     std::array<float, 2> translate = {{ 0, 0 }};
-    TranslateAnchorType translateAnchor = TranslateAnchorType::Default;
+    TranslateAnchorType translateAnchor = TranslateAnchorType::Map;
     float width = 1;
     float offset = 0;
     float blur = 0;
@@ -44,31 +44,6 @@ struct LineProperties {
     }
 };
 
-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 SymbolProperties {
     inline SymbolProperties() {}
 
@@ -133,8 +108,7 @@ struct BackgroundProperties {
 typedef util::variant<
     FillProperties,
     LineProperties,
-    IconProperties,
-    TextProperties,
+    SymbolProperties,
     CompositeProperties,
     RasterProperties,
     BackgroundProperties,
diff --git a/include/mbgl/style/types.hpp b/include/mbgl/style/types.hpp
index 70090a7e36..55b7685fd3 100644
--- a/include/mbgl/style/types.hpp
+++ b/include/mbgl/style/types.hpp
@@ -11,12 +11,13 @@ 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,
+    Symbol,
     Raster,
     Composite,
     Background
@@ -26,170 +27,172 @@ MBGL_DEFINE_ENUM_CLASS(StyleLayerTypeClass, StyleLayerType, {
     { StyleLayerType::Unknown, "unknown" },
     { StyleLayerType::Fill, "fill" },
     { StyleLayerType::Line, "line" },
-    { StyleLayerType::Icon, "icon" },
-    { StyleLayerType::Text, "text" },
+    { StyleLayerType::Symbol, "symbol" },
     { StyleLayerType::Raster, "raster" },
     { StyleLayerType::Composite, "composite" },
     { StyleLayerType::Background, "background" },
     { StyleLayerType(-1), "unknown" },
 });
 
+// -------------------------------------------------------------------------------------------------
 
-enum class WindingType : uint8_t {
+enum class SourceType : uint8_t {
+    Vector,
+    Raster,
+    GeoJSON,
+    Video
+};
+
+MBGL_DEFINE_ENUM_CLASS(SourceTypeClass, SourceType, {
+    { SourceType::Vector, "vector" },
+    { SourceType::Raster, "raster" },
+    { SourceType::GeoJSON, "geojson" },
+    { SourceType::Video, "video" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
+enum class WindingType : bool {
     EvenOdd,
     NonZero,
-    Default = NonZero
 };
 
+MBGL_DEFINE_ENUM_CLASS(WindingTypeClass, WindingType, {
+    { WindingType::EvenOdd, "even-odd" },
+    { WindingType::NonZero, "non-zero" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class CapType : uint8_t {
     Round,
     Butt,
     Square,
-    Default = Butt
 };
 
+MBGL_DEFINE_ENUM_CLASS(CapTypeClass, CapType, {
+    { CapType::Round, "round" },
+    { CapType::Butt, "butt" },
+    { CapType::Square, "square" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class JoinType : uint8_t {
     Miter,
     Bevel,
-    Round,
-    Default = Miter
+    Round
 };
 
-enum class TextPathType : uint8_t {
-    Horizontal,
-    Curve,
-    Default = Horizontal
-};
+MBGL_DEFINE_ENUM_CLASS(JoinTypeClass, JoinType, {
+    { JoinType::Miter, "miter" },
+    { JoinType::Bevel, "bevel" },
+    { JoinType::Round, "round" },
+});
 
-enum class PlacementType : bool {
-    Point,
-    Line,
-    Default = Point
-};
+// -------------------------------------------------------------------------------------------------
 
-enum class TextTransformType : uint8_t {
-    None,
-    Uppercase,
-    Lowercase,
-    Default = None
+enum class TranslateAnchorType : bool {
+    Map,
+    Viewport
 };
 
-enum class TranslateAnchorType : uint8_t {
+MBGL_DEFINE_ENUM_CLASS(TranslateAnchorTypeClass, TranslateAnchorType, {
+    { TranslateAnchorType::Map, "map" },
+    { TranslateAnchorType::Viewport, "viewport" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
+enum class RotateAnchorType : bool {
     Map,
     Viewport,
-    Default = Map
 };
 
-enum class RotateAnchorType : uint8_t {
-    Map,
-    Viewport,
-    Default = Viewport
+MBGL_DEFINE_ENUM_CLASS(RotateAnchorTypeClass, RotateAnchorType, {
+    { RotateAnchorType::Map, "map" },
+    { RotateAnchorType::Viewport, "viewport" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
+enum class PlacementType : bool {
+    Point,
+    Line,
 };
 
+MBGL_DEFINE_ENUM_CLASS(PlacementTypeClass, PlacementType, {
+    { PlacementType::Point, "point" },
+    { PlacementType::Line, "line" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class RotationAlignmentType : bool {
     Map,
     Viewport,
-    Default = Viewport
 };
 
+MBGL_DEFINE_ENUM_CLASS(RotationAlignmentTypeClass, RotationAlignmentType, {
+    { RotationAlignmentType::Map, "map" },
+    { RotationAlignmentType::Viewport, "viewport" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class TextJustifyType : uint8_t {
     Center,
     Left,
-    Right,
-    Default = Center
+    Right
 };
 
+MBGL_DEFINE_ENUM_CLASS(TextJustifyTypeClass, TextJustifyType, {
+    { TextJustifyType::Center, "center" },
+    { TextJustifyType::Left, "left" },
+    { TextJustifyType::Right, "right" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class TextHorizontalAlignType : uint8_t {
     Left,
     Center,
     Right,
-    Default = Center
 };
 
+MBGL_DEFINE_ENUM_CLASS(TextHorizontalAlignTypeClass, TextHorizontalAlignType, {
+    { TextHorizontalAlignType::Left, "left" },
+    { TextHorizontalAlignType::Center, "center" },
+    { TextHorizontalAlignType::Right, "right" },
+});
+
+// -------------------------------------------------------------------------------------------------
+
 enum class TextVerticalAlignType : uint8_t {
     Top,
     Center,
     Bottom,
-    Default = Center
-};
-
-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::Default;
-}
-
-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::Default;
-}
-
-inline TextPathType parseTextPathType(const std::string &path) {
-    if (path == "horizontal") return TextPathType::Horizontal;
-    if (path == "curve") return TextPathType::Curve;
-    return TextPathType::Default;
-}
+MBGL_DEFINE_ENUM_CLASS(TextVerticalAlignTypeClass, TextVerticalAlignType, {
+    { TextVerticalAlignType::Top, "top" },
+    { TextVerticalAlignType::Center, "center" },
+    { TextVerticalAlignType::Bottom, "bottom" },
+});
 
-inline PlacementType parsePlacementType(const std::string &path) {
-    if (path == "point") return PlacementType::Point;
-    if (path == "line") return PlacementType::Line;
-    return PlacementType::Default;
-}
+// -------------------------------------------------------------------------------------------------
 
-inline TextTransformType parseTextTransformType(const std::string& transform) {
-    if (transform == "uppercase") return TextTransformType::Uppercase;
-    if (transform == "lowercase") return TextTransformType::Lowercase;
-    return TextTransformType::Default;
+enum class TextTransformType : uint8_t {
+    None,
+    Uppercase,
+    Lowercase,
 };
 
-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;
-}
+MBGL_DEFINE_ENUM_CLASS(TextTransformTypeClass, TextTransformType, {
+    { TextTransformType::None, "none" },
+    { TextTransformType::Uppercase, "uppercase" },
+    { TextTransformType::Lowercase, "lowercase" },
+});
 
 }
 
diff --git a/include/mbgl/text/placement.hpp b/include/mbgl/text/placement.hpp
index aa03712e30..7700f32f0a 100644
--- a/include/mbgl/text/placement.hpp
+++ b/include/mbgl/text/placement.hpp
@@ -9,15 +9,15 @@
 
 namespace mbgl {
 
-class TextBucket;
-class StyleBucketText;
+class SymbolBucket;
+class StyleBucketSymbol;
 
 class Placement {
 public:
     Placement(int8_t zoom, float placementDepth);
 
-    void addFeature(TextBucket &bucket, const std::vector<Coordinate> &line,
-                    const StyleBucketText &info,
+    void addFeature(SymbolBucket &bucket, const std::vector<Coordinate> &line,
+                    const StyleBucketSymbol &info,
                     const GlyphPositions &face,
                     const Shaping &shaping);