[core] Refactor Buffer

18 files changed, 279 insertions, 196 deletions

diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp
index 7b10fafc93..097410ce3b 100644
--- a/src/mbgl/renderer/circle_bucket.cpp
+++ b/src/mbgl/renderer/circle_bucket.cpp
@@ -18,8 +18,8 @@ CircleBucket::~CircleBucket() {
 }
 
 void CircleBucket::upload(gl::Context& context) {
-    vertexBuffer_.upload(context);
-    elementsBuffer_.upload(context);
+    vertexBuffer = context.createVertexBuffer(std::move(vertices));
+    indexBuffer = context.createIndexBuffer(std::move(triangles));
     uploaded = true;
 }
 
@@ -31,7 +31,7 @@ void CircleBucket::render(Painter& painter,
 }
 
 bool CircleBucket::hasData() const {
-    return !triangleGroups_.empty();
+    return !triangleGroups.empty();
 }
 
 bool CircleBucket::needsClipping() const {
@@ -59,23 +59,27 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) {
             // │ 1     2 │
             // └─────────┘
             //
-            vertexBuffer_.add(x, y, -1, -1); // 1
-            vertexBuffer_.add(x, y, 1, -1); // 2
-            vertexBuffer_.add(x, y, 1, 1); // 3
-            vertexBuffer_.add(x, y, -1, 1); // 4
+            vertices.emplace_back(x, y, -1, -1); // 1
+            vertices.emplace_back(x, y, 1, -1); // 2
+            vertices.emplace_back(x, y, 1, 1); // 3
+            vertices.emplace_back(x, y, -1, 1); // 4
 
-            if (!triangleGroups_.size() || (triangleGroups_.back()->vertex_length + 4 > 65535)) {
+            if (!triangleGroups.size() || (triangleGroups.back()->vertex_length + 4 > 65535)) {
                 // Move to a new group because the old one can't hold the geometry.
-                triangleGroups_.emplace_back(std::make_unique<TriangleGroup>());
+                triangleGroups.emplace_back(std::make_unique<TriangleGroup>());
             }
 
-            TriangleGroup& group = *triangleGroups_.back();
-            auto index = group.vertex_length;
+            TriangleGroup& group = *triangleGroups.back();
+            uint16_t index = group.vertex_length;
 
             // 1, 2, 3
             // 1, 4, 3
-            elementsBuffer_.add(index, index + 1, index + 2);
-            elementsBuffer_.add(index, index + 3, index + 2);
+            triangles.emplace_back(index,
+                                   static_cast<uint16_t>(index + 1),
+                                   static_cast<uint16_t>(index + 2));
+            triangles.emplace_back(index,
+                                   static_cast<uint16_t>(index + 3),
+                                   static_cast<uint16_t>(index + 2));
 
             group.vertex_length += 4;
             group.elements_length += 2;
@@ -87,17 +91,17 @@ void CircleBucket::drawCircles(CircleShader& shader, gl::Context& context) {
     GLbyte* vertexIndex = BUFFER_OFFSET(0);
     GLbyte* elementsIndex = BUFFER_OFFSET(0);
 
-    for (auto& group : triangleGroups_) {
+    for (auto& group : triangleGroups) {
         assert(group);
 
         if (!group->elements_length) continue;
 
-        group->array[0].bind(shader, vertexBuffer_, elementsBuffer_, vertexIndex, context);
+        group->array[0].bind(shader, *vertexBuffer, *indexBuffer, vertexIndex, context);
 
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elementsIndex));
 
-        vertexIndex += group->vertex_length * vertexBuffer_.itemSize;
-        elementsIndex += group->elements_length * elementsBuffer_.itemSize;
+        vertexIndex += group->vertex_length * vertexBuffer->vertexSize;
+        elementsIndex += group->elements_length * indexBuffer->primitiveSize;
     }
 }
 
diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp
index 9e9357d77f..5f4f357d2f 100644
--- a/src/mbgl/renderer/circle_bucket.hpp
+++ b/src/mbgl/renderer/circle_bucket.hpp
@@ -3,17 +3,16 @@
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/map/mode.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/geometry/circle_buffer.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
+#include <mbgl/gl/element_group.hpp>
+#include <mbgl/shader/circle_vertex.hpp>
 
 namespace mbgl {
 
-class CircleVertexBuffer;
 class CircleShader;
 
 class CircleBucket : public Bucket {
-    using TriangleGroup = ElementGroup<3>;
-
 public:
     CircleBucket(const MapMode);
     ~CircleBucket() override;
@@ -28,10 +27,14 @@ public:
     void drawCircles(CircleShader&, gl::Context&);
 
 private:
-    CircleVertexBuffer vertexBuffer_;
-    TriangleElementsBuffer elementsBuffer_;
+    std::vector<CircleVertex> vertices;
+    std::vector<gl::Triangle> triangles;
+
+    using TriangleGroup = gl::ElementGroup<3>;
+    std::vector<std::unique_ptr<TriangleGroup>> triangleGroups;
 
-    std::vector<std::unique_ptr<TriangleGroup>> triangleGroups_;
+    optional<gl::VertexBuffer<CircleVertex>> vertexBuffer;
+    optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
 
     const MapMode mode;
 };
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index 249924abb7..e37ccbff2f 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -1,54 +1,101 @@
 #include <mbgl/renderer/debug_bucket.hpp>
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/shader/plain_shader.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
+#include <mbgl/geometry/debug_font_data.hpp>
 #include <mbgl/util/string.hpp>
 
 #include <mbgl/gl/gl.hpp>
 
-#include <cassert>
+#include <cmath>
 #include <string>
+#include <vector>
 
 namespace mbgl {
 
-DebugBucket::DebugBucket(const OverscaledTileID& id,
-                         const bool renderable_,
-                         const bool complete_,
-                         optional<Timestamp> modified_,
-                         optional<Timestamp> expires_,
-                         MapDebugOptions debugMode_)
-    : renderable(renderable_),
-      complete(complete_),
-      modified(std::move(modified_)),
-      expires(std::move(expires_)),
-      debugMode(debugMode_) {
+std::vector<PlainVertex> buildTextVertexes(const OverscaledTileID& id,
+                                                     const bool renderable,
+                                                     const bool complete,
+                                                     optional<Timestamp> modified,
+                                                     optional<Timestamp> expires,
+                                                     MapDebugOptions debugMode) {
+    std::vector<PlainVertex> textPoints;
+
+    auto addText = [&] (const std::string& text, double left, double baseline, double scale) {
+        for (uint8_t c : text) {
+            if (c < 32 || c >= 127)
+                continue;
+
+            optional<Point<int16_t>> prev;
+
+            const glyph& glyph = simplex[c - 32];
+            for (int32_t j = 0; j < glyph.length; j += 2) {
+                if (glyph.data[j] == -1 && glyph.data[j + 1] == -1) {
+                    prev = {};
+                } else {
+                    Point<int16_t> p {
+                        int16_t(::round(left + glyph.data[j] * scale)),
+                        int16_t(::round(baseline - glyph.data[j + 1] * scale))
+                    };
+
+                    if (prev) {
+                        textPoints.emplace_back(prev->x, prev->y);
+                        textPoints.emplace_back(p.x, p.y);
+                    }
+
+                    prev = p;
+                }
+            }
+
+            left += glyph.width * scale;
+        }
+    };
+
     double baseline = 200;
     if (debugMode & MapDebugOptions::ParseStatus) {
         const std::string text = util::toString(id) + " - " +
                                  (complete ? "complete" : renderable ? "renderable" : "pending");
-        fontBuffer.addText(text.c_str(), 50, baseline, 5);
+        addText(text, 50, baseline, 5);
         baseline += 200;
     }
 
     if (debugMode & MapDebugOptions::Timestamps && modified && expires) {
         const std::string modifiedText = "modified: " + util::iso8601(*modified);
-        fontBuffer.addText(modifiedText.c_str(), 50, baseline, 5);
+        addText(modifiedText, 50, baseline, 5);
 
         const std::string expiresText = "expires: " + util::iso8601(*expires);
-        fontBuffer.addText(expiresText.c_str(), 50, baseline + 200, 5);
+        addText(expiresText, 50, baseline + 200, 5);
     }
+
+    return textPoints;
+}
+
+DebugBucket::DebugBucket(const OverscaledTileID& id,
+                         const bool renderable_,
+                         const bool complete_,
+                         optional<Timestamp> modified_,
+                         optional<Timestamp> expires_,
+                         MapDebugOptions debugMode_,
+                         gl::Context& context)
+    : renderable(renderable_),
+      complete(complete_),
+      modified(std::move(modified_)),
+      expires(std::move(expires_)),
+      debugMode(debugMode_),
+      textVertexes(context.createVertexBuffer(buildTextVertexes(id, renderable_, complete_, modified_, expires_, debugMode_))) {
 }
 
 void DebugBucket::drawLines(PlainShader& shader, gl::Context& context) {
-    if (!fontBuffer.empty()) {
-        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, context);
-        MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index())));
+    if (textVertexes.vertexCount != 0) {
+        array.bind(shader, textVertexes, BUFFER_OFFSET_0, context);
+        MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(textVertexes.vertexCount)));
     }
 }
 
 void DebugBucket::drawPoints(PlainShader& shader, gl::Context& context) {
-    if (!fontBuffer.empty()) {
-        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, context);
-        MBGL_CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index())));
+    if (textVertexes.vertexCount != 0) {
+        array.bind(shader, textVertexes, BUFFER_OFFSET_0, context);
+        MBGL_CHECK_ERROR(glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(textVertexes.vertexCount)));
     }
 }
 
diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp
index 51315967da..59c1e315ea 100644
--- a/src/mbgl/renderer/debug_bucket.hpp
+++ b/src/mbgl/renderer/debug_bucket.hpp
@@ -1,9 +1,13 @@
 #pragma once
 
 #include <mbgl/map/mode.hpp>
-#include <mbgl/geometry/debug_font_buffer.hpp>
-#include <mbgl/geometry/vao.hpp>
 #include <mbgl/util/chrono.hpp>
+#include <mbgl/util/geometry.hpp>
+#include <mbgl/util/optional.hpp>
+#include <mbgl/util/noncopyable.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/vao.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 namespace mbgl {
 
@@ -21,7 +25,8 @@ public:
                 bool complete,
                 optional<Timestamp> modified,
                 optional<Timestamp> expires,
-                MapDebugOptions);
+                MapDebugOptions,
+                gl::Context&);
 
     void drawLines(PlainShader&, gl::Context&);
     void drawPoints(PlainShader&, gl::Context&);
@@ -33,7 +38,7 @@ public:
     const MapDebugOptions debugMode;
 
 private:
-    DebugFontBuffer fontBuffer;
+    gl::VertexBuffer<PlainVertex> textVertexes;
     VertexArrayObject array;
 };
 
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index d07fe5c725..9213c9a777 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -58,14 +58,16 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
                 lineGroups.emplace_back(std::make_unique<LineGroup>());
 
             LineGroup& lineGroup = *lineGroups.back();
-            GLsizei lineIndex = lineGroup.vertex_length;
+            uint16_t lineIndex = lineGroup.vertex_length;
 
-            vertexBuffer.add(ring[0].x, ring[0].y);
-            lineElementsBuffer.add(lineIndex + nVertices - 1, lineIndex);
+            vertices.emplace_back(ring[0].x, ring[0].y);
+            lines.emplace_back(static_cast<uint16_t>(lineIndex + nVertices - 1),
+                               static_cast<uint16_t>(lineIndex));
 
             for (uint32_t i = 1; i < nVertices; i++) {
-                vertexBuffer.add(ring[i].x, ring[i].y);
-                lineElementsBuffer.add(lineIndex + i - 1, lineIndex + i);
+                vertices.emplace_back(ring[i].x, ring[i].y);
+                lines.emplace_back(static_cast<uint16_t>(lineIndex + i - 1),
+                                   static_cast<uint16_t>(lineIndex + i));
             }
 
             lineGroup.vertex_length += nVertices;
@@ -82,12 +84,12 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
         }
 
         TriangleGroup& triangleGroup = *triangleGroups.back();
-        GLsizei triangleIndex = triangleGroup.vertex_length;
+        uint16_t triangleIndex = triangleGroup.vertex_length;
 
         for (uint32_t i = 0; i < nIndicies; i += 3) {
-            triangleElementsBuffer.add(triangleIndex + indices[i],
-                                       triangleIndex + indices[i + 1],
-                                       triangleIndex + indices[i + 2]);
+            triangles.emplace_back(static_cast<uint16_t>(triangleIndex + indices[i]),
+                                   static_cast<uint16_t>(triangleIndex + indices[i + 1]),
+                                   static_cast<uint16_t>(triangleIndex + indices[i + 2]));
         }
 
         triangleGroup.vertex_length += totalVertices;
@@ -96,9 +98,9 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
 }
 
 void FillBucket::upload(gl::Context& context) {
-    vertexBuffer.upload(context);
-    triangleElementsBuffer.upload(context);
-    lineElementsBuffer.upload(context);
+    vertexBuffer = context.createVertexBuffer(std::move(vertices));
+    lineIndexBuffer = context.createIndexBuffer(std::move(lines));
+    triangleIndexBuffer = context.createIndexBuffer(std::move(triangles));
 
     // From now on, we're going to render during the opaque and translucent pass.
     uploaded = true;
@@ -127,11 +129,11 @@ void FillBucket::drawElements(PlainShader& shader,
     for (auto& group : triangleGroups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 1 : 0].bind(
-            shader, vertexBuffer, triangleElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *triangleIndexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * triangleElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * triangleIndexBuffer->primitiveSize;
     }
 }
 
@@ -143,11 +145,11 @@ void FillBucket::drawElements(PatternShader& shader,
     for (auto& group : triangleGroups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 3 : 2].bind(
-            shader, vertexBuffer, triangleElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *triangleIndexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * triangleElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * triangleIndexBuffer->primitiveSize;
     }
 }
 
@@ -159,11 +161,11 @@ void FillBucket::drawVertices(OutlineShader& shader,
     for (auto& group : lineGroups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 1 : 0].bind(
-            shader, vertexBuffer, lineElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *lineIndexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_LINES, group->elements_length * 2, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * lineElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * lineIndexBuffer->primitiveSize;
     }
 }
 
@@ -175,11 +177,11 @@ void FillBucket::drawVertices(OutlinePatternShader& shader,
     for (auto& group : lineGroups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 3 : 2].bind(
-            shader, vertexBuffer, lineElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *lineIndexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_LINES, group->elements_length * 2, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * lineElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * lineIndexBuffer->primitiveSize;
     }
 }
 
diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp
index 2e6d390bfe..9392bb5cf3 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -2,8 +2,10 @@
 
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/geometry/fill_buffer.hpp>
+#include <mbgl/gl/element_group.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 #include <vector>
 #include <memory>
@@ -33,15 +35,18 @@ public:
     void drawVertices(OutlinePatternShader&, gl::Context&, PaintMode);
 
 private:
-    FillVertexBuffer vertexBuffer;
-    TriangleElementsBuffer triangleElementsBuffer;
-    LineElementsBuffer lineElementsBuffer;
+    std::vector<PlainVertex> vertices;
+    std::vector<gl::Line> lines;
+    std::vector<gl::Triangle> triangles;
 
-    typedef ElementGroup<4> TriangleGroup;
-    typedef ElementGroup<4> LineGroup;
-
-    std::vector<std::unique_ptr<TriangleGroup>> triangleGroups;
+    typedef gl::ElementGroup<4> LineGroup;
+    typedef gl::ElementGroup<4> TriangleGroup;
     std::vector<std::unique_ptr<LineGroup>> lineGroups;
+    std::vector<std::unique_ptr<TriangleGroup>> triangleGroups;
+
+    optional<gl::VertexBuffer<PlainVertex>> vertexBuffer;
+    optional<gl::IndexBuffer<gl::Line>> lineIndexBuffer;
+    optional<gl::IndexBuffer<gl::Triangle>> triangleIndexBuffer;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index f892a01ea1..23c8b449b3 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -1,6 +1,5 @@
 #include <mbgl/renderer/line_bucket.hpp>
 #include <mbgl/style/layers/line_layer.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/shader/line_shader.hpp>
 #include <mbgl/shader/linesdf_shader.hpp>
@@ -101,7 +100,7 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
         nextNormal = util::perp(util::unit(convertPoint<double>(firstCoordinate - *currentCoordinate)));
     }
 
-    const int32_t startVertex = vertexBuffer.index();
+    const std::size_t startVertex = vertices.size();
     std::vector<TriangleElement> triangleStore;
 
     for (GLsizei i = 0; i < len; ++i) {
@@ -350,8 +349,8 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
         startOfLine = false;
     }
 
-    const GLsizei endVertex = vertexBuffer.index();
-    const GLsizei vertexCount = endVertex - startVertex;
+    const std::size_t endVertex = vertices.size();
+    const std::size_t vertexCount = endVertex - startVertex;
 
     // Store the triangle/line groups.
     {
@@ -362,10 +361,12 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
 
         assert(triangleGroups.back());
         auto& group = *triangleGroups.back();
+        uint16_t index = group.vertex_length;
+
         for (const auto& triangle : triangleStore) {
-            triangleElementsBuffer.add(group.vertex_length + triangle.a,
-                                       group.vertex_length + triangle.b,
-                                       group.vertex_length + triangle.c);
+            triangles.emplace_back(static_cast<uint16_t>(index + triangle.a),
+                                   static_cast<uint16_t>(index + triangle.b),
+                                   static_cast<uint16_t>(index + triangle.c));
         }
 
         group.vertex_length += vertexCount;
@@ -379,15 +380,15 @@ void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
                                   double endLeft,
                                   double endRight,
                                   bool round,
-                                  int32_t startVertex,
+                                  std::size_t startVertex,
                                   std::vector<TriangleElement>& triangleStore) {
     int8_t tx = round ? 1 : 0;
 
     Point<double> extrude = normal;
     if (endLeft)
         extrude = extrude - (util::perp(normal) * endLeft);
-    e3 = vertexBuffer.add(currentCoordinate.x, currentCoordinate.y, extrude.x, extrude.y, tx, 0, endLeft, distance * LINE_DISTANCE_SCALE)
-         - startVertex;
+    vertices.emplace_back(currentCoordinate.x, currentCoordinate.y, extrude.x, extrude.y, tx, 0, endLeft, distance * LINE_DISTANCE_SCALE);
+    e3 = vertices.size() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
@@ -397,8 +398,8 @@ void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
     extrude = normal * -1.0;
     if (endRight)
         extrude = extrude - (util::perp(normal) * endRight);
-    e3 = vertexBuffer.add(currentCoordinate.x, currentCoordinate.y, extrude.x, extrude.y, tx, 1, -endRight, distance * LINE_DISTANCE_SCALE)
-         - startVertex;
+    vertices.emplace_back(currentCoordinate.x, currentCoordinate.y, extrude.x, extrude.y, tx, 1, -endRight, distance * LINE_DISTANCE_SCALE);
+    e3 = vertices.size() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
@@ -419,13 +420,13 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex,
                                    double distance,
                                    const Point<double>& extrude,
                                    bool lineTurnsLeft,
-                                   int32_t startVertex,
+                                   std::size_t startVertex,
                                    std::vector<TriangleElement>& triangleStore) {
     int8_t ty = lineTurnsLeft;
 
     Point<double> flippedExtrude = extrude * (lineTurnsLeft ? -1.0 : 1.0);
-    e3 = vertexBuffer.add(currentVertex.x, currentVertex.y, flippedExtrude.x, flippedExtrude.y, 0, ty, 0, distance * LINE_DISTANCE_SCALE)
-         - startVertex;
+    vertices.emplace_back(currentVertex.x, currentVertex.y, flippedExtrude.x, flippedExtrude.y, 0, ty, 0, distance * LINE_DISTANCE_SCALE);
+    e3 = vertices.size() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
@@ -438,8 +439,8 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex,
 }
 
 void LineBucket::upload(gl::Context& context) {
-    vertexBuffer.upload(context);
-    triangleElementsBuffer.upload(context);
+    vertexBuffer = context.createVertexBuffer(std::move(vertices));
+    indexBuffer = context.createIndexBuffer(std::move(triangles));
 
     // From now on, we're only going to render during the translucent pass.
     uploaded = true;
@@ -471,11 +472,11 @@ void LineBucket::drawLines(LineShader& shader,
             continue;
         }
         group->array[paintMode == PaintMode::Overdraw ? 1 : 0].bind(
-            shader, vertexBuffer, triangleElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * triangleElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * indexBuffer->primitiveSize;
     }
 }
 
@@ -490,11 +491,11 @@ void LineBucket::drawLineSDF(LineSDFShader& shader,
             continue;
         }
         group->array[paintMode == PaintMode::Overdraw ? 3 : 2].bind(
-            shader, vertexBuffer, triangleElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * triangleElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * indexBuffer->primitiveSize;
     }
 }
 
@@ -509,11 +510,11 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader,
             continue;
         }
         group->array[paintMode == PaintMode::Overdraw ? 5 : 4].bind(
-            shader, vertexBuffer, triangleElementsBuffer, vertex_index, context);
+            shader, *vertexBuffer, *indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * triangleElementsBuffer.itemSize;
+        vertex_index += group->vertex_length * vertexBuffer->vertexSize;
+        elements_index += group->elements_length * indexBuffer->primitiveSize;
     }
 }
 
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index 5ddaca8ae8..8cb73c1d27 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -2,23 +2,21 @@
 
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
-#include <mbgl/geometry/vao.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/geometry/line_buffer.hpp>
+#include <mbgl/gl/element_group.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
+#include <mbgl/shader/line_vertex.hpp>
 #include <mbgl/style/layers/line_layer_properties.hpp>
 
 #include <vector>
 
 namespace mbgl {
 
-class LineVertexBuffer;
-class TriangleElementsBuffer;
 class LineShader;
 class LineSDFShader;
 class LinepatternShader;
 
 class LineBucket : public Bucket {
-    using TriangleGroup = ElementGroup<6>;
 
 public:
     LineBucket(uint32_t overscaling);
@@ -43,24 +41,28 @@ private:
     };
     void addCurrentVertex(const GeometryCoordinate& currentVertex, double& distance,
             const Point<double>& normal, double endLeft, double endRight, bool round,
-            int32_t startVertex, std::vector<LineBucket::TriangleElement>& triangleStore);
+            std::size_t startVertex, std::vector<LineBucket::TriangleElement>& triangleStore);
     void addPieSliceVertex(const GeometryCoordinate& currentVertex, double distance,
-            const Point<double>& extrude, bool lineTurnsLeft, int32_t startVertex,
+            const Point<double>& extrude, bool lineTurnsLeft, std::size_t startVertex,
             std::vector<TriangleElement>& triangleStore);
 
 public:
     style::LineLayoutProperties layout;
 
 private:
-    LineVertexBuffer vertexBuffer;
-    TriangleElementsBuffer triangleElementsBuffer;
-
-    int32_t e1;
-    int32_t e2;
-    int32_t e3;
+    std::vector<LineVertex> vertices;
+    std::vector<gl::Triangle> triangles;
 
+    using TriangleGroup = gl::ElementGroup<6>;
     std::vector<std::unique_ptr<TriangleGroup>> triangleGroups;
 
+    optional<gl::VertexBuffer<LineVertex>> vertexBuffer;
+    optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
+
+    std::ptrdiff_t e1;
+    std::ptrdiff_t e2;
+    std::ptrdiff_t e3;
+
     const uint32_t overscaling;
 };
 
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 4c624a0d7a..825ac053f1 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -39,7 +39,28 @@ namespace mbgl {
 using namespace style;
 
 Painter::Painter(const TransformState& state_)
-    : state(state_) {
+    : state(state_),
+      tileTriangleVertexes(context.createVertexBuffer(std::vector<PlainVertex> {{
+            { 0,            0 },
+            { util::EXTENT, 0 },
+            { 0, util::EXTENT },
+            { util::EXTENT, 0 },
+            { 0, util::EXTENT },
+            { util::EXTENT, util::EXTENT }
+      }})),
+      tileLineStripVertexes(context.createVertexBuffer(std::vector<PlainVertex> {{
+            { 0, 0 },
+            { util::EXTENT, 0 },
+            { util::EXTENT, util::EXTENT },
+            { 0, util::EXTENT },
+            { 0, 0 }
+      }})),
+      rasterVertexes(context.createVertexBuffer(std::vector<RasterVertex> {{
+            { 0, 0, 0, 0 },
+            { util::EXTENT, 0, 32767, 0 },
+            { 0, util::EXTENT, 0, 32767 },
+            { util::EXTENT, util::EXTENT, 32767, 32767 }
+      }})) {
 #ifndef NDEBUG
     gl::debugging::enable();
 #endif
@@ -109,9 +130,6 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
     {
         MBGL_DEBUG_GROUP("upload");
 
-        tileStencilBuffer.upload(context);
-        rasterBoundsBuffer.upload(context);
-        tileBorderBuffer.upload(context);
         spriteAtlas->upload(context, 0);
         lineAtlas->upload(context, 0);
         glyphAtlas->upload(context, 0);
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 2159881ffd..55f5c654b9 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -8,10 +8,10 @@
 #include <mbgl/renderer/render_item.hpp>
 #include <mbgl/renderer/bucket.hpp>
 
-#include <mbgl/geometry/vao.hpp>
-#include <mbgl/geometry/static_vertex_buffer.hpp>
-
+#include <mbgl/gl/vao.hpp>
 #include <mbgl/gl/context.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
+#include <mbgl/shader/raster_vertex.hpp>
 
 #include <mbgl/style/style.hpp>
 
@@ -188,34 +188,9 @@ private:
     std::unique_ptr<Shaders> overdrawShaders;
 #endif
 
-    // Set up the stencil quad we're using to generate the stencil mask.
-    StaticVertexBuffer tileStencilBuffer {
-        // top left triangle
-        {{ 0, 0 }},
-        {{ util::EXTENT, 0 }},
-        {{ 0, util::EXTENT }},
-
-        // bottom right triangle
-        {{ util::EXTENT, 0 }},
-        {{ 0, util::EXTENT }},
-        {{ util::EXTENT, util::EXTENT }},
-    };
-
-    StaticRasterVertexBuffer rasterBoundsBuffer {
-        {{ 0, 0, 0, 0 }},
-        {{ util::EXTENT, 0, 32767, 0 }},
-        {{ 0, util::EXTENT, 0, 32767 }},
-        {{ util::EXTENT, util::EXTENT, 32767, 32767 }},
-    };
-
-    // Set up the tile boundary lines we're using to draw the tile outlines.
-    StaticVertexBuffer tileBorderBuffer {
-        {{ 0, 0 }},
-        {{ util::EXTENT, 0 }},
-        {{ util::EXTENT, util::EXTENT }},
-        {{ 0, util::EXTENT }},
-        {{ 0, 0 }},
-    };
+    gl::VertexBuffer<PlainVertex> tileTriangleVertexes;
+    gl::VertexBuffer<PlainVertex> tileLineStripVertexes;
+    gl::VertexBuffer<RasterVertex> rasterVertexes;
 
     VertexArrayObject tileBorderArray;
 };
diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index af92f17c97..2dab1ccacb 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -46,14 +46,14 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye
         patternShader.u_opacity = properties.backgroundOpacity;
 
         spriteAtlas->bind(true, context, 0);
-        arrayBackgroundPattern.bind(patternShader, tileStencilBuffer, BUFFER_OFFSET(0), context);
+        arrayBackgroundPattern.bind(patternShader, tileTriangleVertexes, BUFFER_OFFSET(0), context);
 
     } else {
         context.program = plainShader.getID();
         plainShader.u_color = properties.backgroundColor;
         plainShader.u_opacity = properties.backgroundOpacity;
 
-        arrayBackground.bind(plainShader, tileStencilBuffer, BUFFER_OFFSET(0), context);
+        arrayBackground.bind(plainShader, tileTriangleVertexes, BUFFER_OFFSET(0), context);
     }
 
     context.stencilTest = false;
@@ -84,7 +84,7 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye
             plainShader.u_matrix = vertexMatrix;
         }
 
-        MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)tileStencilBuffer.index()));
+        MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(tileTriangleVertexes.vertexCount)));
     }
 }
 
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index 03402a2695..e60e861e22 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -29,7 +29,7 @@ void Painter::drawClippingMasks(PaintParameters& parameters, const std::map<Unwr
     context.colorMask = { false, false, false, false };
     context.stencilMask = mask;
 
-    arrayCoveringPlain.bind(plainShader, tileStencilBuffer, BUFFER_OFFSET_0, context);
+    arrayCoveringPlain.bind(plainShader, tileTriangleVertexes, BUFFER_OFFSET_0, context);
 
     for (const auto& stencil : stencils) {
         const auto& id = stencil.first;
@@ -42,7 +42,7 @@ void Painter::drawClippingMasks(PaintParameters& parameters, const std::map<Unwr
 
         const GLint ref = (GLint)(clip.reference.to_ulong());
         context.stencilFunc = { gl::StencilTestFunction::Always, ref, mask };
-        MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index()));
+        MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(tileTriangleVertexes.vertexCount)));
     }
 }
 
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index f19b77462a..a3fc6bff20 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -35,7 +35,7 @@ void Painter::renderDebugText(Tile& tile, const mat4 &matrix) {
         tile.debugBucket->debugMode != frame.debugOptions) {
         tile.debugBucket = std::make_unique<DebugBucket>(
             tile.id, tile.isRenderable(), tile.isComplete(), tile.modified,
-            tile.expires, frame.debugOptions);
+            tile.expires, frame.debugOptions, context);
     }
 
     auto& plainShader = shaders->plain;
@@ -80,10 +80,10 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
     plainShader.u_opacity = 1.0f;
 
     // draw tile outline
-    tileBorderArray.bind(plainShader, tileBorderBuffer, BUFFER_OFFSET_0, context);
+    tileBorderArray.bind(plainShader, tileLineStripVertexes, BUFFER_OFFSET_0, context);
     plainShader.u_color = { 1.0f, 0.0f, 0.0f, 1.0f };
     context.lineWidth = 4.0f * frame.pixelRatio;
-    MBGL_CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index()));
+    MBGL_CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, static_cast<GLsizei>(tileLineStripVertexes.vertexCount)));
 }
 
 #ifndef NDEBUG
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index 8a05456927..243f704952 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -47,7 +47,7 @@ void Painter::renderRaster(PaintParameters& parameters,
         context.depthMask = false;
         setDepthSublayer(0);
 
-        bucket.drawRaster(rasterShader, rasterBoundsBuffer, rasterVAO, context);
+        bucket.drawRaster(rasterShader, rasterVertexes, rasterVAO, context);
     }
 }
 
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index 3edbe3e042..c8f3987134 100644
--- a/src/mbgl/renderer/raster_bucket.cpp
+++ b/src/mbgl/renderer/raster_bucket.cpp
@@ -26,14 +26,14 @@ void RasterBucket::render(Painter& painter,
 }
 
 void RasterBucket::drawRaster(RasterShader& shader,
-                              StaticRasterVertexBuffer& vertices,
+                              gl::VertexBuffer<RasterVertex>& vertices,
                               VertexArrayObject& array,
                               gl::Context& context) {
     assert(texture);
     context.bindTexture(*texture, 0, gl::TextureFilter::Linear);
     context.bindTexture(*texture, 1, gl::TextureFilter::Linear);
     array.bind(shader, vertices, BUFFER_OFFSET_0, context);
-    MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)vertices.index()));
+    MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(vertices.vertexCount)));
 }
 
 bool RasterBucket::hasData() const {
diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp
index db8138b875..1a23e62133 100644
--- a/src/mbgl/renderer/raster_bucket.hpp
+++ b/src/mbgl/renderer/raster_bucket.hpp
@@ -7,9 +7,14 @@
 namespace mbgl {
 
 class RasterShader;
+class RasterVertex;
 class StaticRasterVertexBuffer;
 class VertexArrayObject;
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
 class RasterBucket : public Bucket {
 public:
     RasterBucket(PremultipliedImage&&);
@@ -19,7 +24,7 @@ public:
     bool hasData() const override;
     bool needsClipping() const override;
 
-    void drawRaster(RasterShader&, StaticRasterVertexBuffer&, VertexArrayObject&, gl::Context&);
+    void drawRaster(RasterShader&, gl::VertexBuffer<RasterVertex>&, VertexArrayObject&, gl::Context&);
 
 private:
     PremultipliedImage image;
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 3ef0686e4d..0c41031c93 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -22,12 +22,17 @@ SymbolBucket::SymbolBucket(const MapMode mode_,
 
 void SymbolBucket::upload(gl::Context& context) {
     if (hasTextData()) {
-        text.vertices.upload(context);
-        text.triangles.upload(context);
+        text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices));
+        text.indexBuffer = context.createIndexBuffer(std::move(text.triangles));
     }
+
     if (hasIconData()) {
-        icon.vertices.upload(context);
-        icon.triangles.upload(context);
+        icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices));
+        icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles));
+    }
+
+    if (hasCollisionBoxData()) {
+        collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices));
     }
 
     uploaded = true;
@@ -69,11 +74,11 @@ void SymbolBucket::drawGlyphs(SDFShader& shader,
     for (auto& group : text.groups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 1 : 0].bind(
-            shader, text.vertices, text.triangles, vertex_index, context);
+            shader, *text.vertexBuffer, *text.indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * text.vertices.itemSize;
-        elements_index += group->elements_length * text.triangles.itemSize;
+        vertex_index += group->vertex_length * text.vertexBuffer->vertexSize;
+        elements_index += group->elements_length * text.indexBuffer->primitiveSize;
     }
 }
 
@@ -85,11 +90,11 @@ void SymbolBucket::drawIcons(SDFShader& shader,
     for (auto& group : icon.groups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 1 : 0].bind(
-            shader, icon.vertices, icon.triangles, vertex_index, context);
+            shader, *icon.vertexBuffer, *icon.indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * icon.vertices.itemSize;
-        elements_index += group->elements_length * icon.triangles.itemSize;
+        vertex_index += group->vertex_length * icon.vertexBuffer->vertexSize;
+        elements_index += group->elements_length * icon.indexBuffer->primitiveSize;
     }
 }
 
@@ -101,11 +106,11 @@ void SymbolBucket::drawIcons(IconShader& shader,
     for (auto& group : icon.groups) {
         assert(group);
         group->array[paintMode == PaintMode::Overdraw ? 3 : 2].bind(
-            shader, icon.vertices, icon.triangles, vertex_index, context);
+            shader, *icon.vertexBuffer, *icon.indexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
-        vertex_index += group->vertex_length * icon.vertices.itemSize;
-        elements_index += group->elements_length * icon.triangles.itemSize;
+        vertex_index += group->vertex_length * icon.vertexBuffer->vertexSize;
+        elements_index += group->elements_length * icon.indexBuffer->primitiveSize;
     }
 }
 
@@ -113,7 +118,7 @@ void SymbolBucket::drawCollisionBoxes(CollisionBoxShader& shader,
                                       gl::Context& context) {
     GLbyte* vertex_index = BUFFER_OFFSET_0;
     for (auto& group : collisionBox.groups) {
-        group->array[0].bind(shader, collisionBox.vertices, vertex_index, context);
+        group->array[0].bind(shader, *collisionBox.vertexBuffer, vertex_index, context);
         MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, group->vertex_length));
     }
 }
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index 87c8250d55..36511e964f 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -2,10 +2,11 @@
 
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/map/mode.hpp>
-#include <mbgl/geometry/elements_buffer.hpp>
-#include <mbgl/geometry/text_buffer.hpp>
-#include <mbgl/geometry/icon_buffer.hpp>
-#include <mbgl/geometry/collision_box_buffer.hpp>
+#include <mbgl/gl/element_group.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
+#include <mbgl/shader/texture_rect_vertex.hpp>
+#include <mbgl/shader/collision_box_vertex.hpp>
 #include <mbgl/text/glyph_range.hpp>
 #include <mbgl/style/layers/symbol_layer_properties.hpp>
 
@@ -46,25 +47,35 @@ public:
 private:
     friend class SymbolLayout;
 
-    typedef ElementGroup<2> TextElementGroup;
-    typedef ElementGroup<4> IconElementGroup;
-    typedef ElementGroup<1> CollisionBoxElementGroup;
+    typedef gl::ElementGroup<2> TextElementGroup;
+    typedef gl::ElementGroup<4> IconElementGroup;
+    typedef gl::ElementGroup<1> CollisionBoxElementGroup;
 
     struct TextBuffer {
-        TextVertexBuffer vertices;
-        TriangleElementsBuffer triangles;
+        std::vector<TextureRectVertex> vertices;
+        std::vector<gl::Triangle> triangles;
         std::vector<std::unique_ptr<TextElementGroup>> groups;
+
+        optional<gl::VertexBuffer<TextureRectVertex>> vertexBuffer;
+        optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
     } text;
 
     struct IconBuffer {
-        IconVertexBuffer vertices;
-        TriangleElementsBuffer triangles;
+        std::vector<TextureRectVertex> vertices;
+        std::vector<gl::Triangle> triangles;
         std::vector<std::unique_ptr<IconElementGroup>> groups;
+
+        optional<gl::VertexBuffer<TextureRectVertex>> vertexBuffer;
+        optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
     } icon;
 
     struct CollisionBoxBuffer {
-        CollisionBoxVertexBuffer vertices;
+        std::vector<CollisionBoxVertex> vertices;
+        std::vector<gl::Line> lines;
         std::vector<std::unique_ptr<CollisionBoxElementGroup>> groups;
+
+        optional<gl::VertexBuffer<CollisionBoxVertex>> vertexBuffer;
+        optional<gl::IndexBuffer<gl::Line>> indexBuffer;
     } collisionBox;
 };