[core] Refactor Buffer

87 files changed, 906 insertions, 964 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index 32410927ad..80d36dd03e 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -48,32 +48,11 @@ set(MBGL_CORE_FILES
     # geometry
     src/mbgl/geometry/anchor.hpp
     src/mbgl/geometry/binpack.hpp
-    src/mbgl/geometry/buffer.hpp
-    src/mbgl/geometry/circle_buffer.cpp
-    src/mbgl/geometry/circle_buffer.hpp
-    src/mbgl/geometry/collision_box_buffer.cpp
-    src/mbgl/geometry/collision_box_buffer.hpp
-    src/mbgl/geometry/debug_font_buffer.cpp
-    src/mbgl/geometry/debug_font_buffer.hpp
     src/mbgl/geometry/debug_font_data.hpp
-    src/mbgl/geometry/elements_buffer.cpp
-    src/mbgl/geometry/elements_buffer.hpp
     src/mbgl/geometry/feature_index.cpp
     src/mbgl/geometry/feature_index.hpp
-    src/mbgl/geometry/fill_buffer.cpp
-    src/mbgl/geometry/fill_buffer.hpp
-    src/mbgl/geometry/icon_buffer.cpp
-    src/mbgl/geometry/icon_buffer.hpp
     src/mbgl/geometry/line_atlas.cpp
     src/mbgl/geometry/line_atlas.hpp
-    src/mbgl/geometry/line_buffer.cpp
-    src/mbgl/geometry/line_buffer.hpp
-    src/mbgl/geometry/static_vertex_buffer.cpp
-    src/mbgl/geometry/static_vertex_buffer.hpp
-    src/mbgl/geometry/text_buffer.cpp
-    src/mbgl/geometry/text_buffer.hpp
-    src/mbgl/geometry/vao.cpp
-    src/mbgl/geometry/vao.hpp
 
     # gl
     include/mbgl/gl/gl.hpp
@@ -81,9 +60,11 @@ set(MBGL_CORE_FILES
     src/mbgl/gl/context.hpp
     src/mbgl/gl/debugging.cpp
     src/mbgl/gl/debugging.hpp
+    src/mbgl/gl/element_group.hpp
     src/mbgl/gl/extension.cpp
     src/mbgl/gl/extension.hpp
     src/mbgl/gl/gl.cpp
+    src/mbgl/gl/index_buffer.hpp
     src/mbgl/gl/object.cpp
     src/mbgl/gl/object.hpp
     src/mbgl/gl/state.hpp
@@ -91,8 +72,11 @@ set(MBGL_CORE_FILES
     src/mbgl/gl/types.hpp
     src/mbgl/gl/value.cpp
     src/mbgl/gl/value.hpp
+    src/mbgl/gl/vao.cpp
+    src/mbgl/gl/vao.hpp
     src/mbgl/gl/vertex_array.cpp
     src/mbgl/gl/vertex_array.hpp
+    src/mbgl/gl/vertex_buffer.hpp
 
     # layout
     src/mbgl/layout/clip_lines.cpp
@@ -183,12 +167,18 @@ set(MBGL_CORE_FILES
     # shader
     src/mbgl/shader/circle_shader.cpp
     src/mbgl/shader/circle_shader.hpp
+    src/mbgl/shader/circle_vertex.cpp
+    src/mbgl/shader/circle_vertex.hpp
     src/mbgl/shader/collision_box_shader.cpp
     src/mbgl/shader/collision_box_shader.hpp
+    src/mbgl/shader/collision_box_vertex.cpp
+    src/mbgl/shader/collision_box_vertex.hpp
     src/mbgl/shader/icon_shader.cpp
     src/mbgl/shader/icon_shader.hpp
     src/mbgl/shader/line_shader.cpp
     src/mbgl/shader/line_shader.hpp
+    src/mbgl/shader/line_vertex.cpp
+    src/mbgl/shader/line_vertex.hpp
     src/mbgl/shader/linepattern_shader.cpp
     src/mbgl/shader/linepattern_shader.hpp
     src/mbgl/shader/linesdf_shader.cpp
@@ -201,13 +191,19 @@ set(MBGL_CORE_FILES
     src/mbgl/shader/pattern_shader.hpp
     src/mbgl/shader/plain_shader.cpp
     src/mbgl/shader/plain_shader.hpp
+    src/mbgl/shader/plain_vertex.cpp
+    src/mbgl/shader/plain_vertex.hpp
     src/mbgl/shader/raster_shader.cpp
     src/mbgl/shader/raster_shader.hpp
+    src/mbgl/shader/raster_vertex.cpp
+    src/mbgl/shader/raster_vertex.hpp
     src/mbgl/shader/sdf_shader.cpp
     src/mbgl/shader/sdf_shader.hpp
     src/mbgl/shader/shader.cpp
     src/mbgl/shader/shader.hpp
     src/mbgl/shader/shaders.hpp
+    src/mbgl/shader/texture_rect_vertex.cpp
+    src/mbgl/shader/texture_rect_vertex.hpp
     src/mbgl/shader/uniform.cpp
     src/mbgl/shader/uniform.hpp
 
diff --git a/include/mbgl/gl/gl.hpp b/include/mbgl/gl/gl.hpp
index a499d731d6..4468bf8c12 100644
--- a/include/mbgl/gl/gl.hpp
+++ b/include/mbgl/gl/gl.hpp
@@ -1,6 +1,10 @@
 #pragma once
 
+#include <mbgl/gl/types.hpp>
+
 #include <stdexcept>
+#include <type_traits>
+#include <limits>
 
 #if __APPLE__
     #include "TargetConditionals.h"
@@ -36,12 +40,40 @@ struct Error : std::runtime_error {
 
 void checkError(const char *cmd, const char *file, int line);
 
-} // namespace gl
-} // namespace mbgl
-
 #ifndef NDEBUG
 #define MBGL_CHECK_ERROR(cmd) ([&]() { struct __MBGL_C_E { ~__MBGL_C_E() { ::mbgl::gl::checkError(#cmd, __FILE__, __LINE__); } } __MBGL_C_E; return cmd; }())
 #else
 #define MBGL_CHECK_ERROR(cmd) (cmd)
 #endif
 
+template <typename T> struct AttributeType;
+
+template <> struct AttributeType<int8_t>   : std::integral_constant<GLenum, GL_BYTE> {};
+template <> struct AttributeType<uint8_t>  : std::integral_constant<GLenum, GL_UNSIGNED_BYTE> {};
+template <> struct AttributeType<int16_t>  : std::integral_constant<GLenum, GL_SHORT> {};
+template <> struct AttributeType<uint16_t> : std::integral_constant<GLenum, GL_UNSIGNED_SHORT> {};
+template <> struct AttributeType<int32_t>  : std::integral_constant<GLenum, GL_INT> {};
+template <> struct AttributeType<uint32_t> : std::integral_constant<GLenum, GL_UNSIGNED_INT> {};
+template <> struct AttributeType<float>    : std::integral_constant<GLenum, GL_FLOAT> {};
+
+template <std::size_t memberOffset, class V, class E, std::size_t N>
+void bindVertexAttribute(AttributeLocation location, const E (V::*)[N], const int8_t* offset) {
+    static_assert(std::is_standard_layout<V>::value, "vertex type must use standard layout");
+    static_assert(memberOffset % 4 == 0, "vertex attribute must be optimally aligned");
+    static_assert(1 <= N && N <= 4, "count must be 1, 2, 3, or 4");
+    static_assert(sizeof(V) <= std::numeric_limits<GLsizei>::max(), "vertex type is too big");
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(location));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(location,
+                                           static_cast<GLint>(N),
+                                           AttributeType<E>::value,
+                                           false,
+                                           static_cast<GLsizei>(sizeof(V)),
+                                           offset + memberOffset));
+}
+
+// This has to be a macro because it uses the offsetof macro, which is the only legal way to get a member offset.
+#define MBGL_BIND_VERTEX_ATTRIBUTE(VertexType, member, offset) \
+    ::mbgl::gl::bindVertexAttribute<offsetof(VertexType, member)>(Shader::member, &VertexType::member, offset)
+
+} // namespace gl
+} // namespace mbgl
diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp
deleted file mode 100644
index 2d010e39ac..0000000000
--- a/src/mbgl/geometry/buffer.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#pragma once
-
-#include <mbgl/gl/context.hpp>
-#include <mbgl/platform/log.hpp>
-#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/optional.hpp>
-
-#include <memory>
-#include <cstdlib>
-#include <cassert>
-#include <stdexcept>
-
-namespace mbgl {
-
-template <uint32_t item_size,
-          gl::BufferType target = gl::BufferType::Vertex,
-          uint32_t defaultLength = 8192,
-          bool retainAfterUpload = false>
-class Buffer : private util::noncopyable {
-    static_assert(target == gl::BufferType::Vertex || target == gl::BufferType::Element,
-                  "target must be one of gl::BufferType::Vertex or gl::BufferType::Element");
-
-public:
-    ~Buffer() {
-        cleanup();
-    }
-
-    // Returns the number of elements in this buffer. This is not the number of
-    // bytes, but rather the number of coordinates with associated information.
-    uint32_t index() const {
-        return pos / itemSize;
-    }
-
-    bool empty() const {
-        return pos == 0;
-    }
-
-    // Transfers this buffer to the GPU and binds the buffer to the GL context.
-    void bind(gl::Context& context) {
-        const bool initialized { buffer };
-        if (!initialized) {
-            buffer = context.createBuffer();
-        }
-
-        if (target == gl::BufferType::Vertex) {
-            context.vertexBuffer = *buffer;
-        } else {
-            context.elementBuffer = *buffer;
-        }
-
-        if (!initialized) {
-            if (array == nullptr) {
-                Log::Debug(Event::OpenGL, "Buffer doesn't contain elements");
-                pos = 0;
-            }
-            context.uploadBuffer(target, pos, array);
-            if (!retainAfterUpload) {
-                cleanup();
-            }
-        }
-    }
-
-    void cleanup() {
-        if (array) {
-            free(array);
-            array = nullptr;
-        }
-    }
-
-    gl::BufferID getID() const {
-        return buffer ? *buffer : 0;
-    }
-
-    // Uploads the buffer to the GPU to be available when we need it.
-    void upload(gl::Context& context) {
-        if (!buffer) {
-            bind(context);
-        }
-    }
-
-protected:
-    // increase the buffer size by at least /required/ bytes.
-    void *addElement() {
-        if (buffer) {
-            throw std::runtime_error("Can't add elements after buffer was bound to GPU");
-        }
-        if (length < pos + itemSize) {
-            while (length < pos + itemSize) length += defaultLength;
-            array = realloc(array, length);
-            if (array == nullptr) {
-                throw std::runtime_error("Buffer reallocation failed");
-            }
-        }
-        pos += itemSize;
-        return reinterpret_cast<char *>(array) + (pos - itemSize);
-    }
-
-public:
-    static constexpr const uint32_t itemSize = item_size;
-
-private:
-    // CPU buffer
-    void* array = nullptr;
-
-    // Byte position where we are writing.
-    uint32_t pos = 0;
-
-    // Number of bytes that are valid in this buffer.
-    uint32_t length = 0;
-
-    // GL buffer object handle.
-    mbgl::optional<gl::UniqueBuffer> buffer;
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/circle_buffer.cpp b/src/mbgl/geometry/circle_buffer.cpp
deleted file mode 100644
index cc31fb83bf..0000000000
--- a/src/mbgl/geometry/circle_buffer.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <mbgl/geometry/circle_buffer.hpp>
-
-#include <mbgl/gl/gl.hpp>
-
-#include <climits>
-
-namespace mbgl {
-
-void CircleVertexBuffer::add(vertex_type x, vertex_type y, float ex, float ey) {
-    vertex_type *vertices = static_cast<vertex_type *>(addElement());
-    vertices[0] = (x * 2) + ((ex + 1) / 2);
-    vertices[1] = (y * 2) + ((ey + 1) / 2);
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/circle_buffer.hpp b/src/mbgl/geometry/circle_buffer.hpp
deleted file mode 100644
index 2b188c4003..0000000000
--- a/src/mbgl/geometry/circle_buffer.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-
-namespace mbgl {
-
-class CircleVertexBuffer : public Buffer<
-    4 // 2 bytes per short * 4 of them.
-> {
-public:
-    typedef int16_t vertex_type;
-
-    /*
-     * Add a vertex to this buffer
-     *
-     * @param {number} x vertex position
-     * @param {number} y vertex position
-     * @param {number} ex extrude normal
-     * @param {number} ey extrude normal
-     */
-    void add(vertex_type x, vertex_type y, float ex, float ey);
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/collision_box_buffer.cpp b/src/mbgl/geometry/collision_box_buffer.cpp
deleted file mode 100644
index ae58cf7bca..0000000000
--- a/src/mbgl/geometry/collision_box_buffer.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <mbgl/geometry/collision_box_buffer.hpp>
-#include <mbgl/gl/gl.hpp>
-#include <mbgl/util/math.hpp>
-
-#include <cmath>
-
-namespace mbgl {
-
-uint32_t CollisionBoxVertexBuffer::add(int16_t x, int16_t y, float ox, float oy, float maxzoom, float placementZoom) {
-    const uint32_t idx = index();
-    void *data = addElement();
-
-    int16_t *shorts = static_cast<int16_t *>(data);
-    shorts[0] /* pos */ = x;
-    shorts[1] /* pos */ = y;
-    shorts[2] /* offset */ = ::round(ox); // use 1/64 pixels for placement
-    shorts[3] /* offset */ = ::round(oy);
-
-    uint8_t *ubytes = static_cast<uint8_t *>(data);
-    // a_data
-    ubytes[8] = maxzoom * 10;
-    ubytes[9] = placementZoom * 10;
-
-    return idx;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/collision_box_buffer.hpp b/src/mbgl/geometry/collision_box_buffer.hpp
deleted file mode 100644
index 5360ac3f4c..0000000000
--- a/src/mbgl/geometry/collision_box_buffer.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-#include <array>
-
-namespace mbgl {
-
-class CollisionBoxVertexBuffer : public Buffer <
-    12,
-    gl::BufferType::Vertex,
-    32768
-> {
-public:
-    typedef int16_t vertex_type;
-
-    uint32_t add(int16_t x, int16_t y, float ex, float ey, float maxzoom, float placementZoom);
-};
-
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/debug_font_buffer.cpp b/src/mbgl/geometry/debug_font_buffer.cpp
deleted file mode 100644
index f64ce8816b..0000000000
--- a/src/mbgl/geometry/debug_font_buffer.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <mbgl/geometry/debug_font_buffer.hpp>
-#include <mbgl/geometry/debug_font_data.hpp>
-
-#include <mbgl/gl/gl.hpp>
-#include <cmath>
-#include <cstring>
-
-namespace mbgl {
-
-void DebugFontBuffer::addText(const char *text, double left, double baseline, double scale) {
-    uint16_t *coords = nullptr;
-
-    const size_t len = strlen(text);
-    for (size_t i = 0; i < len; ++i) {
-        if (text[i] < 32 || (unsigned char)(text[i]) >= 127) {
-            continue;
-        }
-
-        const glyph& glyph = simplex[text[i] - 32];
-
-        int16_t prev_x = -1, prev_y = -1, prev = false;
-        for (int32_t j = 0; j < glyph.length; j += 2) {
-            if (glyph.data[j] == -1 && glyph.data[j + 1] == -1) {
-                prev = false;
-            } else {
-                int16_t x = ::round(left + glyph.data[j] * scale);
-                int16_t y = ::round(baseline - glyph.data[j + 1] * scale);
-                if (prev) {
-                    coords = static_cast<uint16_t *>(addElement());
-                    coords[0] = prev_x;
-                    coords[1] = prev_y;
-
-                    coords = static_cast<uint16_t *>(addElement());
-                    coords[0] = x;
-                    coords[1] = y;
-                }
-                prev_x = x; prev_y = y; prev = true;
-            }
-        }
-        left += glyph.width * scale;
-    }
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/debug_font_buffer.hpp b/src/mbgl/geometry/debug_font_buffer.hpp
deleted file mode 100644
index f2debe97a4..0000000000
--- a/src/mbgl/geometry/debug_font_buffer.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-
-namespace mbgl {
-
-class DebugFontBuffer : public Buffer<
-    4 // 2 bytes per coordinate, 2 coordinates
-> {
-public:
-    void addText(const char *text, double left, double baseline, double scale = 1);
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/elements_buffer.cpp b/src/mbgl/geometry/elements_buffer.cpp
deleted file mode 100644
index b7d8cb2015..0000000000
--- a/src/mbgl/geometry/elements_buffer.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <mbgl/geometry/elements_buffer.hpp>
-
-namespace mbgl {
-
-void TriangleElementsBuffer::add(element_type a, element_type b, element_type c) {
-    element_type *elements = static_cast<element_type *>(addElement());
-    elements[0] = a;
-    elements[1] = b;
-    elements[2] = c;
-}
-
-void LineElementsBuffer::add(element_type a, element_type b) {
-    element_type *elements = static_cast<element_type *>(addElement());
-    elements[0] = a;
-    elements[1] = b;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/elements_buffer.hpp b/src/mbgl/geometry/elements_buffer.hpp
deleted file mode 100644
index f995229c9d..0000000000
--- a/src/mbgl/geometry/elements_buffer.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-#include <mbgl/geometry/vao.hpp>
-
-#include <mbgl/util/noncopyable.hpp>
-
-#include <array>
-
-namespace mbgl {
-
-template <uint8_t count>
-struct ElementGroup : public util::noncopyable {
-    std::array<VertexArrayObject, count> array;
-    uint32_t vertex_length;
-    uint32_t elements_length;
-
-    ElementGroup(uint32_t vertex_length_ = 0, uint32_t elements_length_ = 0)
-        : vertex_length(vertex_length_)
-        , elements_length(elements_length_)
-    {
-    }
-};
-
-class TriangleElementsBuffer : public Buffer<
-    6, // bytes per triangle (3 * unsigned short == 6 bytes)
-    gl::BufferType::Element
-> {
-public:
-    typedef uint16_t element_type;
-
-    void add(element_type a, element_type b, element_type c);
-};
-
-
-class LineElementsBuffer : public Buffer<
-    4, // bytes per triangle (2 * unsigned short == 6 bytes)
-    gl::BufferType::Element
-> {
-public:
-    typedef uint16_t element_type;
-
-    void add(element_type a, element_type b);
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/fill_buffer.cpp b/src/mbgl/geometry/fill_buffer.cpp
deleted file mode 100644
index 6cb07ea66a..0000000000
--- a/src/mbgl/geometry/fill_buffer.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <mbgl/geometry/fill_buffer.hpp>
-
-#include <mbgl/gl/gl.hpp>
-
-#include <climits>
-
-namespace mbgl {
-
-void FillVertexBuffer::add(vertex_type x, vertex_type y) {
-    vertex_type *vertices = static_cast<vertex_type *>(addElement());
-    vertices[0] = x;
-    vertices[1] = y;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/fill_buffer.hpp b/src/mbgl/geometry/fill_buffer.hpp
deleted file mode 100644
index a180d9c5a2..0000000000
--- a/src/mbgl/geometry/fill_buffer.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-#include <vector>
-#include <cstdint>
-
-namespace mbgl {
-
-class FillVertexBuffer : public Buffer<
-    4 // bytes per coordinates (2 * unsigned short == 4 bytes)
-> {
-public:
-    typedef int16_t vertex_type;
-
-    void add(vertex_type x, vertex_type y);
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/icon_buffer.cpp b/src/mbgl/geometry/icon_buffer.cpp
deleted file mode 100644
index 745003a548..0000000000
--- a/src/mbgl/geometry/icon_buffer.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <mbgl/geometry/icon_buffer.hpp>
-#include <mbgl/gl/gl.hpp>
-#include <mbgl/util/math.hpp>
-
-#include <cmath>
-
-namespace mbgl {
-
-uint32_t IconVertexBuffer::add(int16_t x, int16_t y, float ox, float oy, int16_t tx, int16_t ty, float minzoom, float maxzoom, float labelminzoom, uint8_t labelangle) {
-    const uint32_t idx = index();
-    void *data = addElement();
-
-    int16_t *shorts = static_cast<int16_t *>(data);
-    shorts[0] /* pos */ = x;
-    shorts[1] /* pos */ = y;
-    shorts[2] /* offset */ = ::round(ox * 64); // use 1/64 pixels for placement
-    shorts[3] /* offset */ = ::round(oy * 64);
-
-    uint16_t *ushorts = static_cast<uint16_t *>(data);
-    // a_texture_pos
-    ushorts[4] /* tex */ = tx / 4;
-    ushorts[5] /* tex */ = ty / 4;
-
-    uint8_t *ubytes = static_cast<uint8_t *>(data);
-    // a_data
-    ubytes[12] /* labelminzoom */ = labelminzoom * 10;
-    ubytes[13] /* labelangle */ = labelangle;
-
-    ubytes[14] /* minzoom */ = minzoom * 10; // 1/10 zoom levels: z16 == 160.
-    ubytes[15] /* maxzoom */ = ::fmin(maxzoom, 25) * 10; // 1/10 zoom levels: z16 == 160.
-
-    return idx;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/icon_buffer.hpp b/src/mbgl/geometry/icon_buffer.hpp
deleted file mode 100644
index 81e17df495..0000000000
--- a/src/mbgl/geometry/icon_buffer.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-
-#include <array>
-
-namespace mbgl {
-
-    class IconVertexBuffer : public Buffer<
-    16
-    > {
-    public:
-        uint32_t add(int16_t x, int16_t y, float ox, float oy, int16_t tx, int16_t ty, float minzoom, float maxzoom, float labelminzoom, uint8_t labelangle);
-
-    };
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/line_buffer.cpp b/src/mbgl/geometry/line_buffer.cpp
deleted file mode 100644
index 0eabf8e1e9..0000000000
--- a/src/mbgl/geometry/line_buffer.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <mbgl/geometry/line_buffer.hpp>
-
-#include <cmath>
-
-namespace mbgl {
-
-uint32_t LineVertexBuffer::add(vertex_type x, vertex_type y, float ex, float ey, bool tx, bool ty, int8_t dir, int32_t linesofar) {
-    uint32_t idx = index();
-    void *data = addElement();
-
-    int16_t *coords = static_cast<int16_t *>(data);
-    coords[0] = (x * 2) | tx;
-    coords[1] = (y * 2) | ty;
-
-    uint8_t *ubytes = static_cast<uint8_t *>(data);
-    // add 128 to store an byte in an unsigned byte
-    ubytes[4] = ::round(extrudeScale * ex) + 128;
-    ubytes[5] = ::round(extrudeScale * ey) + 128;
-
-    // Encode the -1/0/1 direction value into the first two bits of .z of a_data.
-    // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make
-    // room for the direction value). The upper 8 bits of `linesofar` are placed in
-    // the `w` component. `linesofar` is scaled down by `LINE_DISTANCE_SCALE` so that
-    // we can store longer distances while sacrificing precision.
-
-    // Encode the -1/0/1 direction value into .zw coordinates of a_data, which is normally covered
-    // by linesofar, so we need to merge them.
-    // The z component's first bit, as well as the sign bit is reserved for the direction,
-    // so we need to shift the linesofar.
-
-    ubytes[6] = ((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2);
-    ubytes[7] = linesofar >> 6;
-
-    return idx;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/line_buffer.hpp b/src/mbgl/geometry/line_buffer.hpp
deleted file mode 100644
index bfa9a55021..0000000000
--- a/src/mbgl/geometry/line_buffer.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-
-namespace mbgl {
-
-class LineVertexBuffer : public Buffer<
-    8 // 2 coordinates per vertex + 1 linesofar + 1 extrude coord pair == 4 (== 8 bytes)
-> {
-public:
-    typedef int16_t vertex_type;
-
-    /*
-     * Scale the extrusion vector so that the normal length is this value.
-     * Contains the "texture" normals (-1..1). This is distinct from the extrude
-     * normals for line joins, because the x-value remains 0 for the texture
-     * normal array, while the extrude normal actually moves the vertex to create
-     * the acute/bevelled line join.
-     */
-    static const int8_t extrudeScale = 63;
-
-    /*
-     * Add a vertex to this buffer
-     *
-     * @param {number} x vertex position
-     * @param {number} y vertex position
-     * @param {number} ex extrude normal
-     * @param {number} ey extrude normal
-     * @param {number} tx texture normal
-     * @param {number} ty texture normal
-     * @param {number} dir direction of the line cap (-1/0/1)
-     */
-    uint32_t add(vertex_type x, vertex_type y, float ex, float ey, bool tx, bool ty, int8_t dir, int32_t linesofar = 0);
-};
-
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/static_vertex_buffer.cpp b/src/mbgl/geometry/static_vertex_buffer.cpp
deleted file mode 100644
index c66b194748..0000000000
--- a/src/mbgl/geometry/static_vertex_buffer.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <mbgl/geometry/static_vertex_buffer.hpp>
-#include <mbgl/gl/gl.hpp>
-
-namespace mbgl {
-
-StaticVertexBuffer::StaticVertexBuffer(std::initializer_list<std::array<VertexType, 2>> init) {
-    for (const auto& vertex : init) {
-        VertexType* vertices = static_cast<VertexType*>(addElement());
-        vertices[0] = std::get<0>(vertex);
-        vertices[1] = std::get<1>(vertex);
-    }
-}
-
-StaticRasterVertexBuffer::StaticRasterVertexBuffer(std::initializer_list<std::array<VertexType, 4>> init) {
-    for (const auto& vertex : init) {
-        VertexType* vertices = static_cast<VertexType*>(addElement());
-        vertices[0] = std::get<0>(vertex);
-        vertices[1] = std::get<1>(vertex);
-        vertices[2] = std::get<2>(vertex);
-        vertices[3] = std::get<3>(vertex);
-    }
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/static_vertex_buffer.hpp b/src/mbgl/geometry/static_vertex_buffer.hpp
deleted file mode 100644
index edf3b966fd..0000000000
--- a/src/mbgl/geometry/static_vertex_buffer.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-
-#include <array>
-#include <cstdint>
-
-namespace mbgl {
-
-class StaticVertexBuffer : public Buffer<
-    4, // bytes per vertex (2 * signed short == 4 bytes)
-    gl::BufferType::Vertex,
-    32 // default length
-> {
-public:
-    using VertexType = int16_t;
-    StaticVertexBuffer(std::initializer_list<std::array<VertexType, 2>>);
-};
-
-class StaticRasterVertexBuffer : public Buffer<
-    8, // bytes per vertex (4 * signed short == 8 bytes)
-    gl::BufferType::Vertex,
-    32 // default length
-> {
-public:
-    using VertexType = int16_t;
-    StaticRasterVertexBuffer(std::initializer_list<std::array<VertexType, 4>>);
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/geometry/text_buffer.cpp b/src/mbgl/geometry/text_buffer.cpp
deleted file mode 100644
index 8fed7a71d1..0000000000
--- a/src/mbgl/geometry/text_buffer.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <mbgl/geometry/text_buffer.hpp>
-#include <mbgl/gl/gl.hpp>
-#include <mbgl/util/math.hpp>
-
-#include <cmath>
-
-namespace mbgl {
-
-uint32_t TextVertexBuffer::add(int16_t x, int16_t y, float ox, float oy, uint16_t tx, uint16_t ty, float minzoom, float maxzoom, float labelminzoom, uint8_t labelangle) {
-    const uint32_t idx = index();
-    void *data = addElement();
-
-    int16_t *shorts = static_cast<int16_t *>(data);
-    shorts[0] /* pos */ = x;
-    shorts[1] /* pos */ = y;
-    shorts[2] /* offset */ = ::round(ox * 64); // use 1/64 pixels for placement
-    shorts[3] /* offset */ = ::round(oy * 64);
-
-    uint16_t *ushorts = static_cast<uint16_t *>(data);
-    // a_texture_pos
-    ushorts[4] /* tex */ = tx / 4;
-    ushorts[5] /* tex */ = ty / 4;
-
-    uint8_t *ubytes = static_cast<uint8_t *>(data);
-    // a_data
-    ubytes[12] /* labelminzoom */ = labelminzoom * 10;
-    ubytes[13] /* labelangle */ = labelangle;
-
-    ubytes[14] /* minzoom */ = minzoom * 10; // 1/10 zoom levels: z16 == 160.
-    ubytes[15] /* maxzoom */ = ::fmin(maxzoom, 25) * 10; // 1/10 zoom levels: z16 == 160.
-
-    return idx;
-}
-
-} // namespace mbgl
-
diff --git a/src/mbgl/geometry/text_buffer.hpp b/src/mbgl/geometry/text_buffer.hpp
deleted file mode 100644
index 4b46a38770..0000000000
--- a/src/mbgl/geometry/text_buffer.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include <mbgl/geometry/buffer.hpp>
-#include <array>
-
-namespace mbgl {
-
-class TextVertexBuffer : public Buffer <
-    16,
-    gl::BufferType::Vertex,
-    32768
-> {
-public:
-    typedef int16_t vertex_type;
-
-    uint32_t add(int16_t x, int16_t y, float ox, float oy, uint16_t tx, uint16_t ty, float minzoom, float maxzoom, float labelminzoom, uint8_t labelangle);
-};
-
-
-} // namespace mbgl
diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp
index ded7936feb..5837aa3399 100644
--- a/src/mbgl/gl/context.cpp
+++ b/src/mbgl/gl/context.cpp
@@ -91,10 +91,22 @@ UniqueShader Context::createFragmentShader() {
     return UniqueShader{ MBGL_CHECK_ERROR(glCreateShader(GL_FRAGMENT_SHADER)), { this } };
 }
 
-UniqueBuffer Context::createBuffer() {
+UniqueBuffer Context::createVertexBuffer(const void* data, std::size_t size) {
     BufferID id = 0;
     MBGL_CHECK_ERROR(glGenBuffers(1, &id));
-    return UniqueBuffer{ std::move(id), { this } };
+    UniqueBuffer result { std::move(id), { this } };
+    vertexBuffer = result;
+    MBGL_CHECK_ERROR(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW));
+    return result;
+}
+
+UniqueBuffer Context::createIndexBuffer(const void* data, std::size_t size) {
+    BufferID id = 0;
+    MBGL_CHECK_ERROR(glGenBuffers(1, &id));
+    UniqueBuffer result { std::move(id), { this } };
+    elementBuffer = result;
+    MBGL_CHECK_ERROR(glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW));
+    return result;
 }
 
 UniqueTexture Context::createTexture() {
@@ -120,10 +132,6 @@ UniqueFramebuffer Context::createFramebuffer() {
     return UniqueFramebuffer{ std::move(id), { this } };
 }
 
-void Context::uploadBuffer(BufferType type, size_t size, void* data) {
-    MBGL_CHECK_ERROR(glBufferData(static_cast<GLenum>(type), size, data, GL_STATIC_DRAW));
-}
-
 UniqueTexture
 Context::createTexture(uint16_t width, uint16_t height, const void* data, TextureUnit unit) {
     auto obj = createTexture();
diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp
index 0ec846033a..e26b35e7c0 100644
--- a/src/mbgl/gl/context.hpp
+++ b/src/mbgl/gl/context.hpp
@@ -4,6 +4,8 @@
 #include <mbgl/gl/state.hpp>
 #include <mbgl/gl/value.hpp>
 #include <mbgl/gl/texture.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
 #include <memory>
@@ -22,12 +24,24 @@ public:
     UniqueProgram createProgram();
     UniqueShader createVertexShader();
     UniqueShader createFragmentShader();
-    UniqueBuffer createBuffer();
     UniqueTexture createTexture();
     UniqueVertexArray createVertexArray();
     UniqueFramebuffer createFramebuffer();
 
-    void uploadBuffer(BufferType, size_t, void*);
+    template <class V>
+    VertexBuffer<V> createVertexBuffer(std::vector<V>&& v) {
+        return VertexBuffer<V> {
+            v.size(),
+            createVertexBuffer(v.data(), v.size() * sizeof(V))
+        };
+    }
+
+    template <class P>
+    IndexBuffer<P> createIndexBuffer(std::vector<P>&& v) {
+        return IndexBuffer<P> {
+            createIndexBuffer(v.data(), v.size() * sizeof(P))
+        };
+    }
 
     // Create a texture from an image with data.
     template <typename Image>
@@ -98,9 +112,10 @@ public:
     State<value::BindVertexArray> vertexArrayObject;
 
 private:
+    UniqueBuffer createVertexBuffer(const void* data, std::size_t size);
+    UniqueBuffer createIndexBuffer(const void* data, std::size_t size);
     UniqueTexture createTexture(uint16_t width, uint16_t height, const void* data, TextureUnit);
 
-private:
     friend detail::ProgramDeleter;
     friend detail::ShaderDeleter;
     friend detail::BufferDeleter;
diff --git a/src/mbgl/gl/element_group.hpp b/src/mbgl/gl/element_group.hpp
new file mode 100644
index 0000000000..f99a03b679
--- /dev/null
+++ b/src/mbgl/gl/element_group.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <mbgl/gl/vao.hpp>
+#include <mbgl/util/noncopyable.hpp>
+
+#include <array>
+
+namespace mbgl {
+namespace gl {
+
+template <uint8_t count>
+struct ElementGroup : public util::noncopyable {
+    std::array<VertexArrayObject, count> array;
+    uint32_t vertex_length;
+    uint32_t elements_length;
+
+    ElementGroup(uint32_t vertex_length_ = 0, uint32_t elements_length_ = 0)
+        : vertex_length(vertex_length_)
+        , elements_length(elements_length_)
+    {
+    }
+};
+
+} // namespace gl
+} // namespace mbgl
diff --git a/src/mbgl/gl/index_buffer.hpp b/src/mbgl/gl/index_buffer.hpp
new file mode 100644
index 0000000000..f38d7fd4f5
--- /dev/null
+++ b/src/mbgl/gl/index_buffer.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <mbgl/gl/object.hpp>
+
+namespace mbgl {
+namespace gl {
+
+class Line {
+public:
+    Line(uint16_t a_, uint16_t b_)
+        : a(a_), b(b_) {}
+
+    uint16_t a;
+    uint16_t b;
+
+    static constexpr std::size_t IndexCount = 2;
+};
+
+class Triangle {
+public:
+    Triangle(uint16_t a_, uint16_t b_, uint16_t c_)
+        : a(a_), b(b_), c(c_) {}
+
+    uint16_t a;
+    uint16_t b;
+    uint16_t c;
+
+    static constexpr std::size_t IndexCount = 3;
+};
+
+template <class Primitive>
+class IndexBuffer {
+public:
+    static_assert(std::is_same<Primitive, Line>::value || std::is_same<Primitive, Triangle>::value,
+                  "primitive must be Line or Triangle");
+    static constexpr std::size_t primitiveSize = sizeof(Primitive);
+    UniqueBuffer buffer;
+};
+
+} // namespace gl
+} // namespace mbgl
diff --git a/src/mbgl/geometry/vao.cpp b/src/mbgl/gl/vao.cpp
index 2c5e1677ff..527dd214fb 100644
--- a/src/mbgl/geometry/vao.cpp
+++ b/src/mbgl/gl/vao.cpp
@@ -1,4 +1,4 @@
-#include <mbgl/geometry/vao.hpp>
+#include <mbgl/gl/vao.hpp>
 #include <mbgl/gl/vertex_array.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/util/string.hpp>
diff --git a/src/mbgl/geometry/vao.hpp b/src/mbgl/gl/vao.hpp
index 65abab1e4e..c2e3470367 100644
--- a/src/mbgl/geometry/vao.hpp
+++ b/src/mbgl/gl/vao.hpp
@@ -2,6 +2,7 @@
 
 #include <mbgl/shader/shader.hpp>
 #include <mbgl/gl/context.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/optional.hpp>
 
@@ -14,39 +15,39 @@ public:
     VertexArrayObject();
     ~VertexArrayObject();
 
-    template <typename VertexBuffer>
+    template <typename Shader, typename T>
     void bind(Shader& shader,
-              VertexBuffer& vertexBuffer,
+              const gl::VertexBuffer<T>& vertexBuffer,
               int8_t* offset,
               gl::Context& context) {
         bindVertexArrayObject(context);
         if (bound_shader == 0) {
-            vertexBuffer.bind(context);
-            shader.bind(offset);
+            context.vertexBuffer = vertexBuffer.buffer;
+            shader.bind(vertexBuffer, offset);
             if (vertexArray) {
-                storeBinding(shader, vertexBuffer.getID(), 0, offset);
+                storeBinding(shader, vertexBuffer.buffer, 0, offset);
             }
         } else {
-            verifyBinding(shader, vertexBuffer.getID(), 0, offset);
+            verifyBinding(shader, vertexBuffer.buffer, 0, offset);
         }
     }
 
-    template <typename VertexBuffer, typename ElementsBuffer>
+    template <typename Shader, typename T, typename P>
     void bind(Shader& shader,
-              VertexBuffer& vertexBuffer,
-              ElementsBuffer& elementsBuffer,
+              const gl::VertexBuffer<T>& vertexBuffer,
+              const gl::IndexBuffer<P>& indexBuffer,
               int8_t* offset,
               gl::Context& context) {
         bindVertexArrayObject(context);
         if (bound_shader == 0) {
-            vertexBuffer.bind(context);
-            elementsBuffer.bind(context);
-            shader.bind(offset);
+            context.vertexBuffer = vertexBuffer.buffer;
+            context.elementBuffer = indexBuffer.buffer;
+            shader.bind(vertexBuffer, offset);
             if (vertexArray) {
-                storeBinding(shader, vertexBuffer.getID(), elementsBuffer.getID(), offset);
+                storeBinding(shader, vertexBuffer.buffer, indexBuffer.buffer, offset);
             }
         } else {
-            verifyBinding(shader, vertexBuffer.getID(), elementsBuffer.getID(), offset);
+            verifyBinding(shader, vertexBuffer.buffer, indexBuffer.buffer, offset);
         }
     }
 
diff --git a/src/mbgl/gl/vertex_buffer.hpp b/src/mbgl/gl/vertex_buffer.hpp
new file mode 100644
index 0000000000..c77a9a4213
--- /dev/null
+++ b/src/mbgl/gl/vertex_buffer.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <mbgl/gl/object.hpp>
+
+namespace mbgl {
+namespace gl {
+
+template <class Vertex>
+class VertexBuffer {
+public:
+    static constexpr std::size_t vertexSize = sizeof(Vertex);
+    std::size_t vertexCount;
+    UniqueBuffer buffer;
+};
+
+} // namespace gl
+} // namespace mbgl
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index fdd66095fe..1400125dd9 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -464,18 +464,22 @@ void SymbolLayout::addSymbols(Buffer &buffer, const SymbolQuads &symbols, float
         uint8_t glyphAngle = std::round((symbol.glyphAngle / (M_PI * 2)) * 256);
 
         // coordinates (2 triangles)
-        buffer.vertices.add(anchorPoint.x, anchorPoint.y, tl.x, tl.y, tex.x, tex.y, minZoom,
+        buffer.vertices.emplace_back(anchorPoint.x, anchorPoint.y, tl.x, tl.y, tex.x, tex.y, minZoom,
                             maxZoom, placementZoom, glyphAngle);
-        buffer.vertices.add(anchorPoint.x, anchorPoint.y, tr.x, tr.y, tex.x + tex.w, tex.y,
+        buffer.vertices.emplace_back(anchorPoint.x, anchorPoint.y, tr.x, tr.y, tex.x + tex.w, tex.y,
                             minZoom, maxZoom, placementZoom, glyphAngle);
-        buffer.vertices.add(anchorPoint.x, anchorPoint.y, bl.x, bl.y, tex.x, tex.y + tex.h,
+        buffer.vertices.emplace_back(anchorPoint.x, anchorPoint.y, bl.x, bl.y, tex.x, tex.y + tex.h,
                             minZoom, maxZoom, placementZoom, glyphAngle);
-        buffer.vertices.add(anchorPoint.x, anchorPoint.y, br.x, br.y, tex.x + tex.w, tex.y + tex.h,
+        buffer.vertices.emplace_back(anchorPoint.x, anchorPoint.y, br.x, br.y, tex.x + tex.w, tex.y + tex.h,
                             minZoom, maxZoom, placementZoom, glyphAngle);
 
         // add the two triangles, referencing the four coordinates we just inserted.
-        buffer.triangles.add(triangleIndex + 0, triangleIndex + 1, triangleIndex + 2);
-        buffer.triangles.add(triangleIndex + 1, triangleIndex + 2, triangleIndex + 3);
+        buffer.triangles.emplace_back(static_cast<uint16_t>(triangleIndex + 0),
+                                      static_cast<uint16_t>(triangleIndex + 1),
+                                      static_cast<uint16_t>(triangleIndex + 2));
+        buffer.triangles.emplace_back(static_cast<uint16_t>(triangleIndex + 1),
+                                      static_cast<uint16_t>(triangleIndex + 2),
+                                      static_cast<uint16_t>(triangleIndex + 3));
 
         triangleGroup.vertex_length += glyph_vertex_length;
         triangleGroup.elements_length += 2;
@@ -517,14 +521,14 @@ void SymbolLayout::addToDebugBuffers(CollisionTile& collisionTile, SymbolBucket&
                     collisionBox.groups.emplace_back(std::make_unique<SymbolBucket::CollisionBoxElementGroup>());
                 }
 
-                collisionBox.vertices.add(anchor.x, anchor.y, tl.x, tl.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, tr.x, tr.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, tr.x, tr.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, br.x, br.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, br.x, br.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, bl.x, bl.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, bl.x, bl.y, maxZoom, placementZoom);
-                collisionBox.vertices.add(anchor.x, anchor.y, tl.x, tl.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, tl.x, tl.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, tr.x, tr.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, tr.x, tr.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, br.x, br.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, br.x, br.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, bl.x, bl.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, bl.x, bl.y, maxZoom, placementZoom);
+                collisionBox.vertices.emplace_back(anchor.x, anchor.y, tl.x, tl.y, maxZoom, placementZoom);
 
                 auto &group= *collisionBox.groups.back();
                 group.vertex_length += 8;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index e04f7f3900..d5894504e0 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -22,6 +22,7 @@
 #include <mbgl/util/mapbox.hpp>
 #include <mbgl/util/tile_coordinate.hpp>
 #include <mbgl/actor/thread_pool.hpp>
+#include <mbgl/platform/log.hpp>
 
 namespace mbgl {
 
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;
 };
 
diff --git a/src/mbgl/shader/circle_shader.cpp b/src/mbgl/shader/circle_shader.cpp
index b3430d4450..5ad6a73a1a 100644
--- a/src/mbgl/shader/circle_shader.cpp
+++ b/src/mbgl/shader/circle_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/circle_shader.hpp>
 #include <mbgl/shader/circle.vertex.hpp>
 #include <mbgl/shader/circle.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/circle_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ CircleShader::CircleShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void CircleShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 4, offset));
+void CircleShader::bind(const gl::VertexBuffer<CircleVertex>&,
+                        const int8_t* offset) {
+    CircleVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/circle_shader.hpp b/src/mbgl/shader/circle_shader.hpp
index b87d856775..8ea13c7e00 100644
--- a/src/mbgl/shader/circle_shader.hpp
+++ b/src/mbgl/shader/circle_shader.hpp
@@ -6,11 +6,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class CircleVertex;
+
 class CircleShader : public Shader {
 public:
     CircleShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<CircleVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix           = {"u_matrix",           *this};
     Uniform<std::array<float, 2>> u_extrude_scale    = {"u_extrude_scale",    *this};
diff --git a/src/mbgl/shader/circle_vertex.cpp b/src/mbgl/shader/circle_vertex.cpp
new file mode 100644
index 0000000000..3f14fc5747
--- /dev/null
+++ b/src/mbgl/shader/circle_vertex.cpp
@@ -0,0 +1,13 @@
+#include <mbgl/shader/circle_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void CircleVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(CircleVertex) == 4, "expected CircleVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(CircleVertex, a_pos, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/circle_vertex.hpp b/src/mbgl/shader/circle_vertex.hpp
new file mode 100644
index 0000000000..8b4e37431b
--- /dev/null
+++ b/src/mbgl/shader/circle_vertex.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstdint>
+
+namespace mbgl {
+
+class CircleVertex {
+public:
+    /*
+     * @param {number} x vertex position
+     * @param {number} y vertex position
+     * @param {number} ex extrude normal
+     * @param {number} ey extrude normal
+     */
+    CircleVertex(int16_t x, int16_t y, float ex, float ey)
+        : a_pos {
+            static_cast<int16_t>((x * 2) + ((ex + 1) / 2)),
+            static_cast<int16_t>((y * 2) + ((ey + 1) / 2))
+        } {}
+
+    const int16_t a_pos[2];
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/collision_box_shader.cpp b/src/mbgl/shader/collision_box_shader.cpp
index c0a24f0f6f..8fed895c86 100644
--- a/src/mbgl/shader/collision_box_shader.cpp
+++ b/src/mbgl/shader/collision_box_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/collision_box_shader.hpp>
 #include <mbgl/shader/collisionbox.vertex.hpp>
 #include <mbgl/shader/collisionbox.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/collision_box_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,17 +12,9 @@ CollisionBoxShader::CollisionBoxShader(gl::Context& context)
              context) {
 }
 
-void CollisionBoxShader::bind(GLbyte *offset) {
-    const GLint stride = 12;
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_SHORT, false, stride, offset + 4));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 2, GL_UNSIGNED_BYTE, false, stride, offset + 8));
+void CollisionBoxShader::bind(const gl::VertexBuffer<CollisionBoxVertex>&,
+                              const int8_t* offset) {
+    CollisionBoxVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/collision_box_shader.hpp b/src/mbgl/shader/collision_box_shader.hpp
index 65c3ca0146..fe99ef274e 100644
--- a/src/mbgl/shader/collision_box_shader.hpp
+++ b/src/mbgl/shader/collision_box_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class CollisionBoxVertex;
+
 class CollisionBoxShader : public Shader {
 public:
     CollisionBoxShader(gl::Context&);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<CollisionBoxVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4> u_matrix  = {"u_matrix",  *this};
     Uniform<float>   u_scale   = {"u_scale",   *this};
diff --git a/src/mbgl/shader/collision_box_vertex.cpp b/src/mbgl/shader/collision_box_vertex.cpp
new file mode 100644
index 0000000000..d12433ee7d
--- /dev/null
+++ b/src/mbgl/shader/collision_box_vertex.cpp
@@ -0,0 +1,15 @@
+#include <mbgl/shader/collision_box_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void CollisionBoxVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(CollisionBoxVertex) == 10, "expected CollisionBoxVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(CollisionBoxVertex, a_pos, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(CollisionBoxVertex, a_extrude, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(CollisionBoxVertex, a_data, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/collision_box_vertex.hpp b/src/mbgl/shader/collision_box_vertex.hpp
new file mode 100644
index 0000000000..f591a64ca1
--- /dev/null
+++ b/src/mbgl/shader/collision_box_vertex.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstdint>
+#include <cmath>
+
+namespace mbgl {
+
+class CollisionBoxVertex {
+public:
+    CollisionBoxVertex(int16_t x, int16_t y, float ox, float oy, float maxzoom, float placementZoom)
+        : a_pos { x, y },
+          a_extrude {
+              static_cast<int16_t>(::round(ox)),
+              static_cast<int16_t>(::round(oy))
+          },
+          a_data {
+              static_cast<uint8_t>(maxzoom * 10),
+              static_cast<uint8_t>(placementZoom * 10)
+          } {}
+
+    const int16_t a_pos[2];
+    const int16_t a_extrude[2];
+    const uint8_t a_data[2];
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/icon_shader.cpp b/src/mbgl/shader/icon_shader.cpp
index d002e49a49..520c987768 100644
--- a/src/mbgl/shader/icon_shader.cpp
+++ b/src/mbgl/shader/icon_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/icon_shader.hpp>
 #include <mbgl/shader/icon.vertex.hpp>
 #include <mbgl/shader/icon.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/texture_rect_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,20 +12,9 @@ IconShader::IconShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void IconShader::bind(int8_t* offset) {
-    const GLsizei stride = 16;
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_texture_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_texture_pos, 2, GL_UNSIGNED_SHORT, false, stride, offset + 8));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12));
+void IconShader::bind(const gl::VertexBuffer<TextureRectVertex>&,
+                       const int8_t* offset) {
+    TextureRectVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/icon_shader.hpp b/src/mbgl/shader/icon_shader.hpp
index c4f24c91f7..b7d724e05d 100644
--- a/src/mbgl/shader/icon_shader.hpp
+++ b/src/mbgl/shader/icon_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class TextureRectVertex;
+
 class IconShader : public Shader {
 public:
     IconShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<TextureRectVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix          = {"u_matrix",          *this};
     Uniform<std::array<float, 2>> u_extrude_scale   = {"u_extrude_scale",   *this};
diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp
index 684390815c..866c814384 100644
--- a/src/mbgl/shader/line_shader.cpp
+++ b/src/mbgl/shader/line_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/line_shader.hpp>
 #include <mbgl/shader/line.vertex.hpp>
 #include <mbgl/shader/line.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/line_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,12 +12,9 @@ LineShader::LineShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void LineShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4));
+void LineShader::bind(const gl::VertexBuffer<LineVertex>&,
+                      const int8_t* offset) {
+    LineVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/line_shader.hpp b/src/mbgl/shader/line_shader.hpp
index a6be32ebc3..4c1f395dfc 100644
--- a/src/mbgl/shader/line_shader.hpp
+++ b/src/mbgl/shader/line_shader.hpp
@@ -6,11 +6,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class LineVertex;
+
 class LineShader : public Shader {
 public:
     LineShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<LineVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4> u_matrix              = {"u_matrix",             *this};
     Uniform<Color>   u_color               = {"u_color",              *this};
diff --git a/src/mbgl/shader/line_vertex.cpp b/src/mbgl/shader/line_vertex.cpp
new file mode 100644
index 0000000000..a7a51d9fd7
--- /dev/null
+++ b/src/mbgl/shader/line_vertex.cpp
@@ -0,0 +1,14 @@
+#include <mbgl/shader/line_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void LineVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(LineVertex) == 8, "expected LineVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(LineVertex, a_pos, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(LineVertex, a_data, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/line_vertex.hpp b/src/mbgl/shader/line_vertex.hpp
new file mode 100644
index 0000000000..8a85397539
--- /dev/null
+++ b/src/mbgl/shader/line_vertex.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <cstdint>
+#include <cmath>
+
+namespace mbgl {
+
+class LineVertex {
+public:
+    /*
+     * @param {number} x vertex position
+     * @param {number} y vertex position
+     * @param {number} ex extrude normal
+     * @param {number} ey extrude normal
+     * @param {number} tx texture normal
+     * @param {number} ty texture normal
+     * @param {number} dir direction of the line cap (-1/0/1)
+     */
+    LineVertex(int16_t x, int16_t y, float ex, float ey, bool tx, bool ty, int8_t dir, int32_t linesofar = 0)
+        : a_pos {
+              static_cast<int16_t>((x * 2) | tx),
+              static_cast<int16_t>((y * 2) | ty)
+          },
+          a_data {
+              // add 128 to store an byte in an unsigned byte
+              static_cast<uint8_t>(::round(extrudeScale * ex) + 128),
+              static_cast<uint8_t>(::round(extrudeScale * ey) + 128),
+
+              // Encode the -1/0/1 direction value into the first two bits of .z of a_data.
+              // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make
+              // room for the direction value). The upper 8 bits of `linesofar` are placed in
+              // the `w` component. `linesofar` is scaled down by `LINE_DISTANCE_SCALE` so that
+              // we can store longer distances while sacrificing precision.
+
+              // Encode the -1/0/1 direction value into .zw coordinates of a_data, which is normally covered
+              // by linesofar, so we need to merge them.
+              // The z component's first bit, as well as the sign bit is reserved for the direction,
+              // so we need to shift the linesofar.
+              static_cast<uint8_t>(((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2)),
+              static_cast<uint8_t>(linesofar >> 6)
+          } {}
+
+    const int16_t a_pos[2];
+    const uint8_t a_data[4];
+
+    /*
+     * Scale the extrusion vector so that the normal length is this value.
+     * Contains the "texture" normals (-1..1). This is distinct from the extrude
+     * normals for line joins, because the x-value remains 0 for the texture
+     * normal array, while the extrude normal actually moves the vertex to create
+     * the acute/bevelled line join.
+     */
+    static const int8_t extrudeScale = 63;
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/linepattern_shader.cpp b/src/mbgl/shader/linepattern_shader.cpp
index 8f755d4140..86f58d9d99 100644
--- a/src/mbgl/shader/linepattern_shader.cpp
+++ b/src/mbgl/shader/linepattern_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/linepattern_shader.hpp>
 #include <mbgl/shader/linepattern.vertex.hpp>
 #include <mbgl/shader/linepattern.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/line_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,12 +12,9 @@ LinepatternShader::LinepatternShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void LinepatternShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4));
+void LinepatternShader::bind(const gl::VertexBuffer<LineVertex>&,
+                             const int8_t* offset) {
+    LineVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/linepattern_shader.hpp b/src/mbgl/shader/linepattern_shader.hpp
index 89f64d3e1f..c6a30b6c47 100644
--- a/src/mbgl/shader/linepattern_shader.hpp
+++ b/src/mbgl/shader/linepattern_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class LineVertex;
+
 class LinepatternShader : public Shader {
 public:
     LinepatternShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<LineVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix              = {"u_matrix",              *this};
     Uniform<float>                u_linewidth           = {"u_linewidth",           *this};
diff --git a/src/mbgl/shader/linesdf_shader.cpp b/src/mbgl/shader/linesdf_shader.cpp
index 788239459f..5245bc71f4 100644
--- a/src/mbgl/shader/linesdf_shader.cpp
+++ b/src/mbgl/shader/linesdf_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/linesdf_shader.hpp>
 #include <mbgl/shader/linesdfpattern.vertex.hpp>
 #include <mbgl/shader/linesdfpattern.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/line_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,12 +12,9 @@ LineSDFShader::LineSDFShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void LineSDFShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4));
+void LineSDFShader::bind(const gl::VertexBuffer<LineVertex>&,
+                         const int8_t* offset) {
+    LineVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/linesdf_shader.hpp b/src/mbgl/shader/linesdf_shader.hpp
index 4c1fd89635..def4a2a983 100644
--- a/src/mbgl/shader/linesdf_shader.hpp
+++ b/src/mbgl/shader/linesdf_shader.hpp
@@ -6,11 +6,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class LineVertex;
+
 class LineSDFShader : public Shader {
 public:
     LineSDFShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<LineVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix             = {"u_matrix",             *this};
     Uniform<Color>                u_color              = {"u_color",              *this};
diff --git a/src/mbgl/shader/outline_shader.cpp b/src/mbgl/shader/outline_shader.cpp
index 94e981f4a6..3f7642b2c9 100644
--- a/src/mbgl/shader/outline_shader.cpp
+++ b/src/mbgl/shader/outline_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/outline_shader.hpp>
 #include <mbgl/shader/outline.vertex.hpp>
 #include <mbgl/shader/outline.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ OutlineShader::OutlineShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void OutlineShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+void OutlineShader::bind(const gl::VertexBuffer<PlainVertex>&,
+                       const int8_t* offset) {
+    PlainVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/outline_shader.hpp b/src/mbgl/shader/outline_shader.hpp
index ccd8dc4303..09fa9431c9 100644
--- a/src/mbgl/shader/outline_shader.hpp
+++ b/src/mbgl/shader/outline_shader.hpp
@@ -6,11 +6,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class PlainVertex;
+
 class OutlineShader : public Shader {
 public:
     OutlineShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<PlainVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix         = {"u_matrix",        *this};
     Uniform<Color>                u_outline_color  = {"u_outline_color", *this};
diff --git a/src/mbgl/shader/outlinepattern_shader.cpp b/src/mbgl/shader/outlinepattern_shader.cpp
index b33c2b2c1f..afe375f377 100644
--- a/src/mbgl/shader/outlinepattern_shader.cpp
+++ b/src/mbgl/shader/outlinepattern_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/outlinepattern_shader.hpp>
 #include <mbgl/shader/outlinepattern.vertex.hpp>
 #include <mbgl/shader/outlinepattern.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ OutlinePatternShader::OutlinePatternShader(gl::Context& context, Defines defines
              context, defines) {
 }
 
-void OutlinePatternShader::bind(GLbyte *offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+void OutlinePatternShader::bind(const gl::VertexBuffer<PlainVertex>&,
+                                const int8_t* offset) {
+    PlainVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/outlinepattern_shader.hpp b/src/mbgl/shader/outlinepattern_shader.hpp
index 795d390f19..b6b1cda422 100644
--- a/src/mbgl/shader/outlinepattern_shader.hpp
+++ b/src/mbgl/shader/outlinepattern_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class PlainVertex;
+
 class OutlinePatternShader : public Shader {
 public:
     OutlinePatternShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<PlainVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix               = {"u_matrix",               *this};
     Uniform<std::array<float, 2>> u_pattern_tl_a         = {"u_pattern_tl_a",         *this};
diff --git a/src/mbgl/shader/pattern_shader.cpp b/src/mbgl/shader/pattern_shader.cpp
index dba12155f9..632775c181 100644
--- a/src/mbgl/shader/pattern_shader.cpp
+++ b/src/mbgl/shader/pattern_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/pattern_shader.hpp>
 #include <mbgl/shader/pattern.vertex.hpp>
 #include <mbgl/shader/pattern.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ PatternShader::PatternShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void PatternShader::bind(GLbyte *offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+void PatternShader::bind(const gl::VertexBuffer<PlainVertex>&,
+                         const int8_t* offset) {
+    PlainVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/pattern_shader.hpp b/src/mbgl/shader/pattern_shader.hpp
index 6ba141a2cb..2b8590814c 100644
--- a/src/mbgl/shader/pattern_shader.hpp
+++ b/src/mbgl/shader/pattern_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class PlainVertex;
+
 class PatternShader : public Shader {
 public:
     PatternShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<PlainVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix               = {"u_matrix",               *this};
     Uniform<std::array<float, 2>> u_pattern_tl_a         = {"u_pattern_tl_a",         *this};
diff --git a/src/mbgl/shader/plain_shader.cpp b/src/mbgl/shader/plain_shader.cpp
index 8ea008c4ec..a6dce02a32 100644
--- a/src/mbgl/shader/plain_shader.cpp
+++ b/src/mbgl/shader/plain_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/plain_shader.hpp>
 #include <mbgl/shader/fill.vertex.hpp>
 #include <mbgl/shader/fill.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/plain_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ PlainShader::PlainShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void PlainShader::bind(int8_t* offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+void PlainShader::bind(const gl::VertexBuffer<PlainVertex>&,
+                       const int8_t* offset) {
+    PlainVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/plain_shader.hpp b/src/mbgl/shader/plain_shader.hpp
index 2611a5a549..7dbb212e1b 100644
--- a/src/mbgl/shader/plain_shader.hpp
+++ b/src/mbgl/shader/plain_shader.hpp
@@ -6,11 +6,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class PlainVertex;
+
 class PlainShader : public Shader {
 public:
     PlainShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<PlainVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4> u_matrix   = {"u_matrix",  *this};
     Uniform<Color>   u_color    = {"u_color",   *this};
diff --git a/src/mbgl/shader/plain_vertex.cpp b/src/mbgl/shader/plain_vertex.cpp
new file mode 100644
index 0000000000..679ef05c39
--- /dev/null
+++ b/src/mbgl/shader/plain_vertex.cpp
@@ -0,0 +1,13 @@
+#include <mbgl/shader/plain_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void PlainVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(PlainVertex) == 4, "expected PlainVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(PlainVertex, a_pos, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/plain_vertex.hpp b/src/mbgl/shader/plain_vertex.hpp
new file mode 100644
index 0000000000..46abbf737c
--- /dev/null
+++ b/src/mbgl/shader/plain_vertex.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <cstdint>
+
+namespace mbgl {
+
+class PlainVertex {
+public:
+    PlainVertex(int16_t x, int16_t y)
+        : a_pos { x, y } {}
+
+    const int16_t a_pos[2];
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp
index 8133b396c6..f3909bb2ac 100644
--- a/src/mbgl/shader/raster_shader.cpp
+++ b/src/mbgl/shader/raster_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/raster_shader.hpp>
 #include <mbgl/shader/raster.vertex.hpp>
 #include <mbgl/shader/raster.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/raster_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,14 +12,9 @@ RasterShader::RasterShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void RasterShader::bind(int8_t* offset) {
-    const GLint stride = 8;
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_texture_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_texture_pos, 2, GL_SHORT, false, stride, offset + 4));
+void RasterShader::bind(const gl::VertexBuffer<RasterVertex>&,
+                       const int8_t* offset) {
+    RasterVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/raster_shader.hpp b/src/mbgl/shader/raster_shader.hpp
index e583b2337d..ca474ede15 100644
--- a/src/mbgl/shader/raster_shader.hpp
+++ b/src/mbgl/shader/raster_shader.hpp
@@ -5,11 +5,18 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class RasterVertex;
+
 class RasterShader : public Shader {
 public:
     RasterShader(gl::Context&, Defines defines = None);
 
-    void bind(int8_t* offset) final;
+    void bind(const gl::VertexBuffer<RasterVertex>&,
+              const int8_t* offset);
 
     UniformMatrix<4>              u_matrix            = {"u_matrix",            *this};
     Uniform<int32_t>              u_image0            = {"u_image0",            *this};
diff --git a/src/mbgl/shader/raster_vertex.cpp b/src/mbgl/shader/raster_vertex.cpp
new file mode 100644
index 0000000000..c77cacef88
--- /dev/null
+++ b/src/mbgl/shader/raster_vertex.cpp
@@ -0,0 +1,14 @@
+#include <mbgl/shader/raster_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void RasterVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(RasterVertex) == 8, "expected RasterVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(RasterVertex, a_pos, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(RasterVertex, a_texture_pos, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/raster_vertex.hpp b/src/mbgl/shader/raster_vertex.hpp
new file mode 100644
index 0000000000..b983010d3d
--- /dev/null
+++ b/src/mbgl/shader/raster_vertex.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+
+namespace mbgl {
+
+class RasterVertex {
+public:
+    RasterVertex(int16_t x, int16_t y, int16_t tx, int16_t ty)
+        : a_pos {
+              x,
+              y
+          },
+          a_texture_pos {
+              tx,
+              ty
+          } {}
+
+    const int16_t a_pos[2];
+    const int16_t a_texture_pos[2];
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/sdf_shader.cpp b/src/mbgl/shader/sdf_shader.cpp
index 3b4aa69535..804e96706f 100644
--- a/src/mbgl/shader/sdf_shader.cpp
+++ b/src/mbgl/shader/sdf_shader.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/shader/sdf_shader.hpp>
 #include <mbgl/shader/sdf.vertex.hpp>
 #include <mbgl/shader/sdf.fragment.hpp>
-#include <mbgl/gl/gl.hpp>
+#include <mbgl/shader/texture_rect_vertex.hpp>
 
 namespace mbgl {
 
@@ -12,20 +12,9 @@ SDFShader::SDFShader(gl::Context& context, Defines defines)
              context, defines) {
 }
 
-void SDFShader::bind(int8_t* offset) {
-    const int stride = 16;
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_texture_pos));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_texture_pos, 2, GL_UNSIGNED_SHORT, false, stride, offset + 8));
-
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data));
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12));
+void SDFShader::bind(const gl::VertexBuffer<TextureRectVertex>&,
+                     const int8_t* offset) {
+    TextureRectVertex::bind(offset);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/sdf_shader.hpp b/src/mbgl/shader/sdf_shader.hpp
index f7fde3e539..2e7f6d6795 100644
--- a/src/mbgl/shader/sdf_shader.hpp
+++ b/src/mbgl/shader/sdf_shader.hpp
@@ -6,10 +6,19 @@
 
 namespace mbgl {
 
+namespace gl {
+template <class> class VertexBuffer;
+} // namespace gl
+
+class TextureRectVertex;
+
 class SDFShader : public Shader {
 public:
     SDFShader(gl::Context&, Defines defines = None);
 
+    void bind(const gl::VertexBuffer<TextureRectVertex>&,
+              const int8_t* offset);
+
     UniformMatrix<4>              u_matrix          = {"u_matrix",          *this};
     Uniform<std::array<float, 2>> u_extrude_scale   = {"u_extrude_scale",   *this};
     Uniform<Color>                u_color           = {"u_color",           *this};
@@ -25,8 +34,6 @@ public:
     Uniform<int32_t>              u_pitch_with_map  = {"u_pitch_with_map",  *this};
     Uniform<int32_t>              u_texture         = {"u_texture",         *this};
     Uniform<int32_t>              u_fadetexture     = {"u_fadetexture",     *this};
-
-    void bind(int8_t* offset) final;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/shader.hpp b/src/mbgl/shader/shader.hpp
index 91dd8ed518..977edebd7e 100644
--- a/src/mbgl/shader/shader.hpp
+++ b/src/mbgl/shader/shader.hpp
@@ -22,8 +22,6 @@ public:
 
     gl::UniformLocation getUniformLocation(const char* uniform) const;
 
-    virtual void bind(int8_t *offset) = 0;
-
     enum Defines : bool {
         None = false,
         Overdraw = true,
@@ -36,6 +34,7 @@ protected:
            gl::Context&,
            Defines defines = Defines::None);
 
+public:
     static constexpr gl::AttributeLocation         a_pos = 0;
     static constexpr gl::AttributeLocation     a_extrude = 1;
     static constexpr gl::AttributeLocation      a_offset = 2;
diff --git a/src/mbgl/shader/texture_rect_vertex.cpp b/src/mbgl/shader/texture_rect_vertex.cpp
new file mode 100644
index 0000000000..4693ada9e7
--- /dev/null
+++ b/src/mbgl/shader/texture_rect_vertex.cpp
@@ -0,0 +1,16 @@
+#include <mbgl/shader/texture_rect_vertex.hpp>
+#include <mbgl/shader/shader.hpp>
+#include <mbgl/gl/gl.hpp>
+
+namespace mbgl {
+
+void TextureRectVertex::bind(const int8_t* offset) {
+    static_assert(sizeof(TextureRectVertex) == 16, "expected TextureRectVertex size");
+
+    MBGL_BIND_VERTEX_ATTRIBUTE(TextureRectVertex, a_pos, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(TextureRectVertex, a_offset, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(TextureRectVertex, a_texture_pos, offset);
+    MBGL_BIND_VERTEX_ATTRIBUTE(TextureRectVertex, a_data, offset);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/shader/texture_rect_vertex.hpp b/src/mbgl/shader/texture_rect_vertex.hpp
new file mode 100644
index 0000000000..e2e2526f16
--- /dev/null
+++ b/src/mbgl/shader/texture_rect_vertex.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <cstdint>
+#include <cmath>
+
+namespace mbgl {
+
+// A vertex that holds a position, offset and texture coordinate. Used for symbol layer icons and glyphs.
+class TextureRectVertex {
+public:
+    TextureRectVertex(int16_t x, int16_t y, float ox, float oy, uint16_t tx, uint16_t ty, float minzoom, float maxzoom, float labelminzoom, uint8_t labelangle)
+        : a_pos {
+              x,
+              y
+          },
+          a_offset {
+              static_cast<int16_t>(::round(ox * 64)),  // use 1/64 pixels for placement
+              static_cast<int16_t>(::round(oy * 64))
+          },
+          a_texture_pos {
+              static_cast<uint16_t>(tx / 4),
+              static_cast<uint16_t>(ty / 4)
+          },
+          a_data {
+              static_cast<uint8_t>(labelminzoom * 10), // 1/10 zoom levels: z16 == 160
+              static_cast<uint8_t>(labelangle),
+              static_cast<uint8_t>(minzoom * 10),
+              static_cast<uint8_t>(::fmin(maxzoom, 25) * 10)
+          } {}
+
+    const int16_t a_pos[2];
+    const int16_t a_offset[2];
+    const uint16_t a_texture_pos[2];
+    const uint8_t a_data[4];
+
+    static void bind(const int8_t* offset);
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp
index ec0540b1ad..1375263107 100644
--- a/src/mbgl/tile/tile.cpp
+++ b/src/mbgl/tile/tile.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/tile/tile_observer.hpp>
 #include <mbgl/renderer/debug_bucket.hpp>
 #include <mbgl/util/string.hpp>
+#include <mbgl/platform/log.hpp>
 
 namespace mbgl {
 
diff --git a/test/gl/object.test.cpp b/test/gl/object.test.cpp
index 0502bbc847..1a90cec83b 100644
--- a/test/gl/object.test.cpp
+++ b/test/gl/object.test.cpp
@@ -87,13 +87,6 @@ TEST(GLObject, Store) {
     context.performCleanup();
     EXPECT_TRUE(context.empty());
 
-    mbgl::gl::UniqueBuffer buffer = context.createBuffer();
-    EXPECT_NE(buffer.get(), 0u);
-    buffer.reset();
-    EXPECT_FALSE(context.empty());
-    context.performCleanup();
-    EXPECT_TRUE(context.empty());
-
     mbgl::gl::UniqueTexture texture = context.createTexture();
     EXPECT_NE(texture.get(), 0u);
     texture.reset();