Merge pull request #415 from mapbox/fix-vao

Line drawing slowdowns on OS X

include/mbgl/geometry/buffer.hpp

@@ -62,6 +62,10 @@ public:
         }
     }
 
+    inline GLuint getID() const {
+        return buffer;
+    }
+
 protected:
     // increase the buffer size by at least /required/ bytes.
     inline void *addElement() {
@@ -72,7 +76,7 @@ protected:
             while (length < pos + itemSize) length += defaultLength;
             array = realloc(array, length);
             if (array == nullptr) {
-                throw std::runtime_error("Buffer reallocation failed¯");
+                throw std::runtime_error("Buffer reallocation failed");
             }
         }
         pos += itemSize;
@@ -106,7 +110,7 @@ private:
     size_t length = 0;
 
     // GL buffer ID
-    uint32_t buffer = 0;
+    GLuint buffer = 0;
 };
 
 }

include/mbgl/geometry/elements_buffer.hpp

@@ -4,10 +4,13 @@
 #include <mbgl/geometry/buffer.hpp>
 #include <mbgl/geometry/vao.hpp>
 
+#include <array>
+
 namespace mbgl {
 
+template <int count>
 struct ElementGroup {
-    VertexArrayObject array;
+    std::array<VertexArrayObject, count> array;
     uint32_t vertex_length;
     uint32_t elements_length;
 

include/mbgl/geometry/static_vertex_buffer.hpp

@@ -0,0 +1,26 @@
+#ifndef MBGL_GEOMETRY_STATIC_VERTEX_BUFFER
+#define MBGL_GEOMETRY_STATIC_VERTEX_BUFFER
+
+#include <mbgl/geometry/buffer.hpp>
+
+#include <vector>
+#include <cstddef>
+#include <cstdint>
+#include <cmath>
+
+namespace mbgl {
+
+class StaticVertexBuffer : public Buffer<
+    4, // bytes per vertex (2 * signed short == 4 bytes)
+    GL_ARRAY_BUFFER,
+    32 // default length
+> {
+public:
+    typedef int16_t vertex_type;
+
+    StaticVertexBuffer(std::initializer_list<std::pair<int16_t, int16_t>> init);
+};
+
+}
+
+#endif

include/mbgl/geometry/vao.hpp

@@ -1,101 +1,74 @@
 #ifndef MBGL_GEOMETRY_VAO
 #define MBGL_GEOMETRY_VAO
 
+#include <mbgl/shader/shader.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <stdexcept>
 
 namespace mbgl {
 
+#if GL_ARB_vertex_array_object
 class VertexArrayObject {
 public:
     template <typename Shader, typename VertexBuffer>
-    void bind(Shader& shader, VertexBuffer& vertex_buffer, char *offset) {
-#if GL_ARB_vertex_array_object
-        if (!vao) {
-            glGenVertexArrays(1, &vao);
-            glBindVertexArray(vao);
-        } else {
-            // We have been given the correct information.
-            glBindVertexArray(vao);
-        }
-
-        if (shader_ptr != &shader) {
-            if (shader_ptr != nullptr) {
-                fprintf(stderr, "shader rebind!");
-            }
-#endif
-            vertex_buffer.bind();
+    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, char *offset) {
+        bindVertexArrayObject();
+        if (bound_shader == 0) {
+            vertexBuffer.bind();
             shader.bind(offset);
-
-#if GL_ARB_vertex_array_object
-            shader_ptr = &shader;
-            vertex_buffer_ptr = &vertex_buffer;
-            elements_buffer_ptr = nullptr;
-            offset_ptr = offset;
-        } else if (vertex_buffer_ptr != &vertex_buffer) {
-            throw std::runtime_error("trying to bind VAO to another vertex buffer");
-        } else if (elements_buffer_ptr != nullptr) {
-            throw std::runtime_error("trying to bind VAO to another elements buffer");
-        } else if (offset_ptr != offset) {
-            throw std::runtime_error("trying to bind VAO to another offset");
+            storeBinding(shader, vertexBuffer.getID(), 0, offset);
+        } else {
+            verifyBinding(shader, vertexBuffer.getID(), 0, offset);
         }
-#endif
     }
 
     template <typename Shader, typename VertexBuffer, typename ElementsBuffer>
-    void bind(Shader& shader, VertexBuffer& vertex_buffer, ElementsBuffer& elements_buffer, char *offset) {
-#if GL_ARB_vertex_array_object
-        if (!vao) {
-            glGenVertexArrays(1, &vao);
-            glBindVertexArray(vao);
-        } else {
-            // We have been given the correct information.
-            glBindVertexArray(vao);
-        }
-
-        if (shader_ptr != &shader) {
-#endif
-            vertex_buffer.bind();
-            elements_buffer.bind();
+    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, ElementsBuffer &elementsBuffer, char *offset) {
+        bindVertexArrayObject();
+        if (bound_shader == 0) {
+            vertexBuffer.bind();
+            elementsBuffer.bind();
             shader.bind(offset);
-
-#if GL_ARB_vertex_array_object
-            shader_ptr = &shader;
-            vertex_buffer_ptr = &vertex_buffer;
-            elements_buffer_ptr = &elements_buffer;
-            offset_ptr = offset;
-        } else if (vertex_buffer_ptr != &vertex_buffer) {
-            throw std::runtime_error("trying to bind VAO to another vertex buffer");
-        } else if (elements_buffer_ptr != &elements_buffer) {
-            throw std::runtime_error("trying to bind VAO to another elements buffer");
-        } else if (offset_ptr != offset) {
-            throw std::runtime_error("trying to bind VAO to another offset");
+            storeBinding(shader, vertexBuffer.getID(), elementsBuffer.getID(), offset);
+        } else {
+            verifyBinding(shader, vertexBuffer.getID(), elementsBuffer.getID(), offset);
         }
-#endif
     }
 
-    ~VertexArrayObject() {
-#if GL_ARB_vertex_array_object
-        if (vao) {
-            glDeleteVertexArrays(1, &vao);
-        }
-#endif
-    }
+    ~VertexArrayObject();
 
 private:
-#if GL_ARB_vertex_array_object
+    void bindVertexArrayObject();
+    void storeBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer, char *offset);
+    void verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer, char *offset);
+
     GLuint vao = 0;
 
     // For debug reasons, we're storing the bind information so that we can
     // detect errors and report
-    void *shader_ptr = nullptr;
-    void *vertex_buffer_ptr = nullptr;
-    void *elements_buffer_ptr = nullptr;
-    char *offset_ptr = 0;
-#endif
+    GLuint bound_shader = 0;
+    const char *bound_shader_name = "";
+    GLuint bound_vertex_buffer = 0;
+    GLuint bound_elements_buffer = 0;
+    char *bound_offset = 0;
 };
 
+#else
+
+class VertexArrayObject {
+public:
+    template <typename Shader, typename Buffers>
+    void bind(Shader& shader, Buffers& buffers, char *offset) {
+        for (auto &buffer : buffers) {
+            buffer.bind();
+        }
+        shader.bind(offset);
+    }
+};
+
+#endif
+
 }
 
 #endif

include/mbgl/geometry/vertex_buffer.hpp

@@ -1,35 +0,0 @@
-#ifndef MBGL_GEOMETRY_VERTEX_BUFFER
-#define MBGL_GEOMETRY_VERTEX_BUFFER
-
-#include <vector>
-#include <cstddef>
-#include <cstdint>
-#include <cmath>
-
-namespace mbgl {
-
-class VertexBuffer {
-public:
-    typedef int16_t vertex_type;
-    VertexBuffer(std::initializer_list<vertex_type> init);
-    ~VertexBuffer();
-
-    /*
-     * Returns the number of elements in this buffer. This is not the number of
-     * bytes, but rather the number of coordinates with associated information.
-     */
-    size_t index() const;
-
-    /*
-     * Transfers this buffer to the GPU and binds the buffer to the GL context.
-     */
-    void bind();
-
-private:
-    const std::vector<vertex_type> array;
-    uint32_t buffer = 0;
-};
-
-}
-
-#endif

include/mbgl/platform/gl.hpp

@@ -26,9 +26,12 @@
     #elif TARGET_OS_MAC
         #include <OpenGL/OpenGL.h>
         #include <OpenGL/gl.h>
-        #define glGenVertexArrays glGenVertexArraysAPPLE
-        #define glBindVertexArray glBindVertexArrayAPPLE
-        #define glDeleteVertexArrays glDeleteVertexArraysAPPLE
+        #if GL_APPLE_vertex_array_object
+            #define GL_ARB_vertex_array_object 1
+            #define glGenVertexArrays glGenVertexArraysAPPLE
+            #define glBindVertexArray glBindVertexArrayAPPLE
+            #define glDeleteVertexArrays glDeleteVertexArraysAPPLE
+        #endif
     #else
         #error Unsupported Apple platform
     #endif

include/mbgl/renderer/fill_bucket.hpp

@@ -34,9 +34,8 @@ class FillBucket : public Bucket {
     static void *realloc(void *data, void *ptr, unsigned int size);
     static void free(void *userData, void *ptr);
 
-
-    typedef ElementGroup triangle_group_type;
-    typedef ElementGroup line_group_type;
+    typedef ElementGroup<2> triangle_group_type;
+    typedef ElementGroup<1> line_group_type;
 public:
     FillBucket(FillVertexBuffer& vertexBuffer,
                TriangleElementsBuffer& triangleElementsBuffer,

include/mbgl/renderer/line_bucket.hpp

@@ -20,8 +20,8 @@ class LinejoinShader;
 struct pbf;
 
 class LineBucket : public Bucket {
-    typedef ElementGroup triangle_group_type;
-    typedef ElementGroup point_group_type;
+    typedef ElementGroup<1> triangle_group_type;
+    typedef ElementGroup<1> point_group_type;
 public:
     LineBucket(LineVertexBuffer& vertexBuffer,
                TriangleElementsBuffer& triangleElementsBuffer,

include/mbgl/renderer/painter.hpp

@@ -3,7 +3,7 @@
 
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/geometry/vao.hpp>
-#include <mbgl/geometry/vertex_buffer.hpp>
+#include <mbgl/geometry/static_vertex_buffer.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/renderer/frame_history.hpp>
@@ -176,16 +176,16 @@ public:
     std::unique_ptr<GaussianShader> gaussianShader;
 
     // Set up the stencil quad we're using to generate the stencil mask.
-    VertexBuffer tileStencilBuffer = {
+    StaticVertexBuffer tileStencilBuffer = {
         // top left triangle
-        0, 0,
-        4096, 0,
-        0, 4096,
+        { 0, 0 },
+        { 4096, 0 },
+        { 0, 4096 },
 
         // bottom right triangle
-        4096, 0,
-        0, 4096,
-        4096, 4096
+        { 4096, 0 },
+        { 0, 4096 },
+        { 4096, 4096 },
     };
 
     VertexArrayObject coveringPlainArray;
@@ -197,12 +197,12 @@ public:
     VertexArrayObject matteArray;
 
     // Set up the tile boundary lines we're using to draw the tile outlines.
-    VertexBuffer tileBorderBuffer = {
-        0, 0,
-        4096, 0,
-        4096, 4096,
-        0, 4096,
-        0, 0
+    StaticVertexBuffer tileBorderBuffer = {
+        { 0, 0 },
+        { 4096, 0 },
+        { 4096, 4096 },
+        { 0, 4096 },
+        { 0, 0 },
     };
 
     VertexArrayObject tileBorderArray;

include/mbgl/renderer/raster_bucket.hpp

@@ -11,7 +11,7 @@
 namespace mbgl {
 
 class RasterShader;
-class VertexBuffer;
+class StaticVertexBuffer;
 class VertexArrayObject;
 
 class RasterBucket : public Bucket {
@@ -26,9 +26,9 @@ public:
     const StyleBucketRaster &properties;
     PrerenderedTexture texture;
 
-    void drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array);
+    void drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array);
 
-    void drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array, GLuint texture);
+    void drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture);
 
     Raster raster;
 

include/mbgl/renderer/symbol_bucket.hpp

@@ -50,6 +50,9 @@ typedef std::vector<Symbol> Symbols;
 
 
 class SymbolBucket : public Bucket {
+    typedef ElementGroup<1> TextElementGroup;
+    typedef ElementGroup<1> IconElementGroup;
+
 public:
     SymbolBucket(const StyleBucketSymbol &properties, Collision &collision);
 
@@ -94,13 +97,13 @@ private:
     struct {
         TextVertexBuffer vertices;
         TriangleElementsBuffer triangles;
-        std::vector<ElementGroup> groups;
+        std::vector<TextElementGroup> groups;
     } text;
 
     struct {
         IconVertexBuffer vertices;
         TriangleElementsBuffer triangles;
-        std::vector<ElementGroup> groups;
+        std::vector<IconElementGroup> groups;
     } icon;
 
 };

include/mbgl/shader/shader.hpp

@@ -9,13 +9,18 @@ namespace mbgl {
 
 class Shader : private util::noncopyable {
 public:
-    Shader(const char *vertex, const char *fragment);
+    Shader(const char *name, const char *vertex, const char *fragment);
     ~Shader();
+    const char *name;
     bool valid;
     uint32_t program;
 
     void setMatrix(const std::array<float, 16>& matrix);
 
+    inline uint32_t getID() const {
+        return program;
+    }
+
 private:
     bool compileShader(uint32_t *shader, uint32_t type, const char *source);
 

src/geometry/static_vertex_buffer.cpp

@@ -0,0 +1,14 @@
+#include <mbgl/geometry/static_vertex_buffer.hpp>
+#include <mbgl/platform/gl.hpp>
+
+namespace mbgl {
+
+StaticVertexBuffer::StaticVertexBuffer(std::initializer_list<std::pair<int16_t, int16_t>> init) {
+    for (const std::pair<int16_t, int16_t> &vertex : init) {
+        vertex_type *vertices = static_cast<vertex_type *>(addElement());
+        vertices[0] = vertex.first;
+        vertices[1] = vertex.second;
+    }
+}
+
+}

src/geometry/vao.cpp

@@ -0,0 +1,46 @@
+#include <mbgl/geometry/vao.hpp>
+
+namespace mbgl {
+
+#if GL_ARB_vertex_array_object
+
+VertexArrayObject::~VertexArrayObject() {
+    if (vao) {
+        glDeleteVertexArrays(1, &vao);
+    }
+}
+
+void VertexArrayObject::bindVertexArrayObject() {
+    if (!vao) {
+        glGenVertexArrays(1, &vao);
+    }
+    glBindVertexArray(vao);
+}
+
+void VertexArrayObject::verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer,
+                                      char *offset) {
+    if (bound_shader != shader.getID()) {
+        throw std::runtime_error(std::string("trying to rebind VAO to another shader from " +
+                                             std::to_string(bound_shader) + "(" + bound_shader_name + ") to " +
+                                             std::to_string(shader.getID()) + "(" + shader.name + ")" ));
+    } else if (bound_offset != offset) {
+        throw std::runtime_error("trying to bind VAO to another offset");
+    } else if (bound_vertex_buffer != vertexBuffer) {
+        throw std::runtime_error("trying to bind VAO to another vertex buffer");
+    } else if (bound_elements_buffer != elementsBuffer) {
+        throw std::runtime_error("trying to bind VAO to another elements buffer");
+    }
+}
+
+void VertexArrayObject::storeBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer,
+                                     char *offset) {
+    bound_shader = shader.getID();
+    bound_shader_name = shader.name;
+    bound_offset = offset;
+    bound_vertex_buffer = vertexBuffer;
+    bound_elements_buffer = elementsBuffer;
+}
+
+#endif
+
+}

src/geometry/vertex_buffer.cpp

@@ -1,28 +0,0 @@
-#include <mbgl/geometry/vertex_buffer.hpp>
-#include <mbgl/platform/gl.hpp>
-
-using namespace mbgl;
-
-
-VertexBuffer::VertexBuffer(std::initializer_list<int16_t> init) : array(init) {}
-
-VertexBuffer::~VertexBuffer() {
-    if (buffer != 0) {
-        glDeleteBuffers(1, &buffer);
-    }
-}
-
-size_t VertexBuffer::index() const {
-    // We store 2 coordinates per vertex + 1 linesofar + 1 extrude coord pair == 4 (== 8 bytes)
-    return array.size() / 2;
-}
-
-void VertexBuffer::bind() {
-    if (buffer == 0) {
-        glGenBuffers(1, &buffer);
-        glBindBuffer(GL_ARRAY_BUFFER, buffer);
-        glBufferData(GL_ARRAY_BUFFER, array.size() * sizeof(vertex_type), array.data(), GL_STATIC_DRAW);
-    } else {
-        glBindBuffer(GL_ARRAY_BUFFER, buffer);
-    }
-}

src/map/transform.cpp

@@ -128,9 +128,9 @@ void Transform::getLonLat(double &lon, double &lat) const {
 }
 
 void Transform::getLonLatZoom(double &lon, double &lat, double &zoom) const {
-    uv::readlock lock(mtx);
-
     getLonLat(lon, lat);
+
+    uv::readlock lock(mtx);
     zoom = getZoom();
 }
 
@@ -192,7 +192,7 @@ void Transform::setZoom(const double zoom, const timestamp duration) {
 double Transform::getZoom() const {
     uv::readlock lock(mtx);
 
-    return log(final.scale) / M_LN2;
+    return std::log(final.scale) / M_LN2;
 }
 
 double Transform::getScale() const {

src/renderer/fill_bucket.cpp

@@ -216,7 +216,7 @@ void FillBucket::drawElements(PlainShader& shader) {
     char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
     char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
-        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         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;
@@ -227,7 +227,7 @@ void FillBucket::drawElements(PatternShader& shader) {
     char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
     char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
-        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group.array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         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;
@@ -238,7 +238,7 @@ void FillBucket::drawVertices(OutlineShader& shader) {
     char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
     char *elements_index = BUFFER_OFFSET(line_elements_start * lineElementsBuffer.itemSize);
     for (line_group_type& group : lineGroups) {
-        group.array.bind(shader, vertexBuffer, lineElementsBuffer, vertex_index);
+        group.array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index);
         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;

src/renderer/line_bucket.cpp

@@ -367,7 +367,7 @@ void LineBucket::drawLines(LineShader& shader) {
         if (!group.elements_length) {
             continue;
         }
-        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         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;
@@ -381,7 +381,7 @@ void LineBucket::drawPoints(LinejoinShader& shader) {
         if (!group.elements_length) {
             continue;
         }
-        group.array.bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
+        group.array[0].bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
         glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index);
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * pointElementsBuffer.itemSize;

src/renderer/painter.cpp

@@ -67,17 +67,17 @@ void Painter::setup() {
 }
 
 void Painter::setupShaders() {
-    plainShader = std::make_unique<PlainShader>();
-    outlineShader = std::make_unique<OutlineShader>();
-    lineShader = std::make_unique<LineShader>();
-    linejoinShader = std::make_unique<LinejoinShader>();
-    patternShader = std::make_unique<PatternShader>();
-    iconShader = std::make_unique<IconShader>();
-    rasterShader = std::make_unique<RasterShader>();
-    textShader = std::make_unique<TextShader>();
-    dotShader = std::make_unique<DotShader>();
-    compositeShader = std::make_unique<CompositeShader>();
-    gaussianShader = std::make_unique<GaussianShader>();
+    if (!plainShader) plainShader = std::make_unique<PlainShader>();
+    if (!outlineShader) outlineShader = std::make_unique<OutlineShader>();
+    if (!lineShader) lineShader = std::make_unique<LineShader>();
+    if (!linejoinShader) linejoinShader = std::make_unique<LinejoinShader>();
+    if (!patternShader) patternShader = std::make_unique<PatternShader>();
+    if (!iconShader) iconShader = std::make_unique<IconShader>();
+    if (!rasterShader) rasterShader = std::make_unique<RasterShader>();
+    if (!textShader) textShader = std::make_unique<TextShader>();
+    if (!dotShader) dotShader = std::make_unique<DotShader>();
+    if (!compositeShader) compositeShader = std::make_unique<CompositeShader>();
+    if (!gaussianShader) gaussianShader = std::make_unique<GaussianShader>();
 }
 
 void Painter::cleanup() {

src/renderer/raster_bucket.cpp

@@ -17,14 +17,14 @@ bool RasterBucket::setImage(const std::string &data) {
     return raster.load(data);
 }
 
-void RasterBucket::drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array) {
+void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array) {
     raster.bind(true);
     shader.setImage(0);
     array.bind(shader, vertices, BUFFER_OFFSET(0));
     glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
 }
 
-void RasterBucket::drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array, GLuint texture) {
+void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture) {
     raster.bind(texture);
     shader.setImage(0);
     array.bind(shader, vertices, BUFFER_OFFSET(0));

src/renderer/symbol_bucket.cpp

@@ -348,7 +348,7 @@ void SymbolBucket::addSymbols(Buffer &buffer, const PlacedGlyphs &symbols, float
 
         // We're generating triangle fans, so we always start with the first
         // coordinate in this polygon.
-        ElementGroup &triangleGroup = buffer.groups.back();
+        TextElementGroup &triangleGroup = buffer.groups.back();
         uint32_t triangleIndex = triangleGroup.vertex_length;
 
         // coordinates (2 triangles)
@@ -373,8 +373,8 @@ void SymbolBucket::addSymbols(Buffer &buffer, const PlacedGlyphs &symbols, float
 void SymbolBucket::drawGlyphs(TextShader &shader) {
     char *vertex_index = BUFFER_OFFSET(0);
     char *elements_index = BUFFER_OFFSET(0);
-    for (ElementGroup &group : text.groups) {
-        group.array.bind(shader, text.vertices, text.triangles, vertex_index);
+    for (TextElementGroup &group : text.groups) {
+        group.array[0].bind(shader, text.vertices, text.triangles, vertex_index);
         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;
@@ -384,8 +384,8 @@ void SymbolBucket::drawGlyphs(TextShader &shader) {
 void SymbolBucket::drawIcons(IconShader &shader) {
     char *vertex_index = BUFFER_OFFSET(0);
     char *elements_index = BUFFER_OFFSET(0);
-    for (ElementGroup &group : icon.groups) {
-        group.array.bind(shader, icon.vertices, icon.triangles, vertex_index);
+    for (IconElementGroup &group : icon.groups) {
+        group.array[0].bind(shader, icon.vertices, icon.triangles, vertex_index);
         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;

src/shader/composite_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 CompositeShader::CompositeShader()
     : Shader(
+         "composite",
          shaders[COMPOSITE_SHADER].vertex,
          shaders[COMPOSITE_SHADER].fragment
          ) {

src/shader/dot_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 DotShader::DotShader()
 : Shader(
+         "dot",
          shaders[DOT_SHADER].vertex,
          shaders[DOT_SHADER].fragment
          ) {

src/shader/gaussian_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 GaussianShader::GaussianShader()
     : Shader(
+         "gaussian",
          shaders[GAUSSIAN_SHADER].vertex,
          shaders[GAUSSIAN_SHADER].fragment
          ) {

src/shader/icon_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 IconShader::IconShader()
     : Shader(
+         "icon",
          shaders[ICON_SHADER].vertex,
          shaders[ICON_SHADER].fragment
          ) {

src/shader/line_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 LineShader::LineShader()
     : Shader(
+        "line",
         shaders[LINE_SHADER].vertex,
         shaders[LINE_SHADER].fragment
     ) {

src/shader/linejoin_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 LinejoinShader::LinejoinShader()
     : Shader(
+        "linejoin",
         shaders[LINEJOIN_SHADER].vertex,
         shaders[LINEJOIN_SHADER].fragment
     ) {

src/shader/outline_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 OutlineShader::OutlineShader()
     : Shader(
+        "outline",
         shaders[OUTLINE_SHADER].vertex,
         shaders[OUTLINE_SHADER].fragment
     ) {

src/shader/pattern_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 PatternShader::PatternShader()
     : Shader(
+        "pattern",
         shaders[PATTERN_SHADER].vertex,
         shaders[PATTERN_SHADER].fragment
     ) {

src/shader/plain_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 PlainShader::PlainShader()
     : Shader(
+        "plain",
         shaders[PLAIN_SHADER].vertex,
         shaders[PLAIN_SHADER].fragment
     ) {

src/shader/raster_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 RasterShader::RasterShader()
     : Shader(
+         "raster",
          shaders[RASTER_SHADER].vertex,
          shaders[RASTER_SHADER].fragment
          ) {

src/shader/shader.cpp

@@ -8,8 +8,9 @@
 
 using namespace mbgl;
 
-Shader::Shader(const GLchar *vertSource, const GLchar *fragSource)
-    : valid(false),
+Shader::Shader(const char *name, const GLchar *vertSource, const GLchar *fragSource)
+    : name(name),
+      valid(false),
       program(0) {
     util::timer timer("shader compilation", Event::Shader);
 

src/shader/text_shader.cpp

@@ -8,6 +8,7 @@ using namespace mbgl;
 
 TextShader::TextShader()
     : Shader(
+        "text",
         shaders[TEXT_SHADER].vertex,
         shaders[TEXT_SHADER].fragment
     ) {