[core] Use gl::Program to resolve some rough edges in the GL binding types

* Extract `ignore` util to separate header.
* `Segment` now tracks offset and length of indices, rather than primitives. This is more natural.
* Introduce `VertexVector` and `IndexVector` types. These types carry information about the intended draw mode (`Triangles`, `LineStrip`, etc.), and ensure that elements are always appended in a group size appropriate for that draw mode, for both indexed and unindexed rendering.
* `Program`, rather than `Drawable`, is now the unifying object for draw calls. `Program` is the best place to type check the draw call, because it is typed to carry information about the intended primitive, vertex type, attributes, and uniforms.
* Use the debug shaders for debug tile rendering, like gl-js.
* Fix the draw mode for background. It was drawing triangle strips with a triangles array. Surprised this didn’t cause issues. Now it’s type checked.

19 files changed, 186 insertions, 163 deletions

diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp
index 08f2a144a1..ba2285c4eb 100644
--- a/src/mbgl/renderer/circle_bucket.cpp
+++ b/src/mbgl/renderer/circle_bucket.cpp
@@ -46,7 +46,7 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) {
 
             if (segments.empty() || segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
                 // Move to a new segments because the old one can't hold the geometry.
-                segments.emplace_back(vertices.size(), triangles.size());
+                segments.emplace_back(vertices.vertexSize(), triangles.indexSize());
             }
 
             // this geometry will be of the Point type, and we'll derive
@@ -73,7 +73,7 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) {
             triangles.emplace_back(index, index + 3, index + 2);
 
             segment.vertexLength += vertexLength;
-            segment.primitiveLength += 2;
+            segment.indexLength += 6;
         }
     }
 }
diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp
index d5df06f110..a93b052d68 100644
--- a/src/mbgl/renderer/circle_bucket.hpp
+++ b/src/mbgl/renderer/circle_bucket.hpp
@@ -20,12 +20,12 @@ public:
     bool hasData() const override;
     void addGeometry(const GeometryCollection&);
 
-    std::vector<CircleVertex> vertices;
-    std::vector<gl::Triangle> triangles;
+    gl::VertexVector<CircleVertex> vertices;
+    gl::IndexVector<gl::Triangles> triangles;
     std::vector<gl::Segment> segments;
 
     optional<gl::VertexBuffer<CircleVertex>> vertexBuffer;
-    optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
+    optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
 
     const MapMode mode;
 };
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index 931d1bf30d..4beb16a996 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -10,13 +10,14 @@
 
 namespace mbgl {
 
-std::vector<FillVertex> buildTextVertices(const OverscaledTileID& id,
-                                                     const bool renderable,
-                                                     const bool complete,
-                                                     optional<Timestamp> modified,
-                                                     optional<Timestamp> expires,
-                                                     MapDebugOptions debugMode) {
-    std::vector<FillVertex> textPoints;
+gl::VertexVector<FillVertex, gl::Lines>
+buildTextVertices(const OverscaledTileID& id,
+                  const bool renderable,
+                  const bool complete,
+                  optional<Timestamp> modified,
+                  optional<Timestamp> expires,
+                  MapDebugOptions debugMode) {
+    gl::VertexVector<FillVertex, gl::Lines> textLines;
 
     auto addText = [&] (const std::string& text, double left, double baseline, double scale) {
         for (uint8_t c : text) {
@@ -36,8 +37,8 @@ std::vector<FillVertex> buildTextVertices(const OverscaledTileID& id,
                     };
 
                     if (prev) {
-                        textPoints.emplace_back(FillAttributes::vertex(*prev));
-                        textPoints.emplace_back(FillAttributes::vertex(p));
+                        textLines.emplace_back(FillAttributes::vertex(*prev),
+                                               FillAttributes::vertex(p));
                     }
 
                     prev = p;
@@ -64,7 +65,7 @@ std::vector<FillVertex> buildTextVertices(const OverscaledTileID& id,
         addText(expiresText, 50, baseline + 200, 5);
     }
 
-    return textPoints;
+    return textLines;
 }
 
 DebugBucket::DebugBucket(const OverscaledTileID& id,
diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp
index 9b19e7f949..4c173786ae 100644
--- a/src/mbgl/renderer/debug_bucket.hpp
+++ b/src/mbgl/renderer/debug_bucket.hpp
@@ -32,7 +32,7 @@ public:
     const optional<Timestamp> expires;
     const MapDebugOptions debugMode;
 
-    gl::VertexBuffer<FillVertex> vertexBuffer;
+    gl::VertexBuffer<FillVertex, gl::Lines> vertexBuffer;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index 2eee8f2d6d..96e44d6903 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -39,7 +39,7 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
                 throw GeometryTooLongException();
         }
 
-        std::size_t startVertices = vertices.size();
+        std::size_t startVertices = vertices.vertexSize();
 
         for (const auto& ring : polygon) {
             std::size_t nVertices = ring.size();
@@ -48,7 +48,7 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
                 continue;
 
             if (lineSegments.empty() || lineSegments.back().vertexLength + nVertices > std::numeric_limits<uint16_t>::max()) {
-                lineSegments.emplace_back(vertices.size(), lines.size());
+                lineSegments.emplace_back(vertices.vertexSize(), lines.indexSize());
             }
 
             auto& lineSegment = lineSegments.back();
@@ -64,7 +64,7 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
             }
 
             lineSegment.vertexLength += nVertices;
-            lineSegment.primitiveLength += nVertices;
+            lineSegment.indexLength += nVertices * 2;
         }
 
         std::vector<uint32_t> indices = mapbox::earcut(polygon);
@@ -73,7 +73,7 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
         assert(nIndicies % 3 == 0);
 
         if (triangleSegments.empty() || triangleSegments.back().vertexLength + totalVertices > std::numeric_limits<uint16_t>::max()) {
-            triangleSegments.emplace_back(startVertices, triangles.size());
+            triangleSegments.emplace_back(startVertices, triangles.indexSize());
         }
 
         auto& triangleSegment = triangleSegments.back();
@@ -87,7 +87,7 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
         }
 
         triangleSegment.vertexLength += totalVertices;
-        triangleSegment.primitiveLength += nIndicies / 3;
+        triangleSegment.indexLength += nIndicies;
     }
 }
 
diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp
index b2c549a758..4ea558b629 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -19,15 +19,15 @@ public:
 
     void addGeometry(const GeometryCollection&);
 
-    std::vector<FillVertex> vertices;
-    std::vector<gl::Line> lines;
-    std::vector<gl::Triangle> triangles;
+    gl::VertexVector<FillVertex> vertices;
+    gl::IndexVector<gl::Lines> lines;
+    gl::IndexVector<gl::Triangles> triangles;
     std::vector<gl::Segment> lineSegments;
     std::vector<gl::Segment> triangleSegments;
 
     optional<gl::VertexBuffer<FillVertex>> vertexBuffer;
-    optional<gl::IndexBuffer<gl::Line>> lineIndexBuffer;
-    optional<gl::IndexBuffer<gl::Triangle>> triangleIndexBuffer;
+    optional<gl::IndexBuffer<gl::Lines>> lineIndexBuffer;
+    optional<gl::IndexBuffer<gl::Triangles>> triangleIndexBuffer;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 1db075652c..554fef5ca7 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -96,7 +96,7 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
         nextNormal = util::perp(util::unit(convertPoint<double>(firstCoordinate - *currentCoordinate)));
     }
 
-    const std::size_t startVertex = vertices.size();
+    const std::size_t startVertex = vertices.vertexSize();
     std::vector<TriangleElement> triangleStore;
 
     for (std::size_t i = 0; i < len; ++i) {
@@ -345,11 +345,11 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
         startOfLine = false;
     }
 
-    const std::size_t endVertex = vertices.size();
+    const std::size_t endVertex = vertices.vertexSize();
     const std::size_t vertexCount = endVertex - startVertex;
 
     if (segments.empty() || segments.back().vertexLength + vertexCount > std::numeric_limits<uint16_t>::max()) {
-        segments.emplace_back(startVertex, triangles.size());
+        segments.emplace_back(startVertex, triangles.indexSize());
     }
 
     auto& segment = segments.back();
@@ -361,7 +361,7 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates) {
     }
 
     segment.vertexLength += vertexCount;
-    segment.primitiveLength += triangleStore.size();
+    segment.indexLength += triangleStore.size() * 3;
 }
 
 void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
@@ -376,7 +376,7 @@ void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
     if (endLeft)
         extrude = extrude - (util::perp(normal) * endLeft);
     vertices.emplace_back(LineAttributes::vertex(currentCoordinate, extrude, { round, false }, endLeft, distance * LINE_DISTANCE_SCALE));
-    e3 = vertices.size() - 1 - startVertex;
+    e3 = vertices.vertexSize() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
@@ -387,7 +387,7 @@ void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
     if (endRight)
         extrude = extrude - (util::perp(normal) * endRight);
     vertices.emplace_back(LineAttributes::vertex(currentCoordinate, extrude, { round, true }, -endRight, distance * LINE_DISTANCE_SCALE));
-    e3 = vertices.size() - 1 - startVertex;
+    e3 = vertices.vertexSize() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
@@ -412,7 +412,7 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex,
                                    std::vector<TriangleElement>& triangleStore) {
     Point<double> flippedExtrude = extrude * (lineTurnsLeft ? -1.0 : 1.0);
     vertices.emplace_back(LineAttributes::vertex(currentVertex, flippedExtrude, { false, lineTurnsLeft }, 0, distance * LINE_DISTANCE_SCALE));
-    e3 = vertices.size() - 1 - startVertex;
+    e3 = vertices.vertexSize() - 1 - startVertex;
     if (e1 >= 0 && e2 >= 0) {
         triangleStore.emplace_back(e1, e2, e3);
     }
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index 4d78a80123..9903ca1842 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -26,12 +26,12 @@ public:
 
     style::LineLayoutProperties layout;
 
-    std::vector<LineVertex> vertices;
-    std::vector<gl::Triangle> triangles;
+    gl::VertexVector<LineVertex> vertices;
+    gl::IndexVector<gl::Triangles> triangles;
     std::vector<gl::Segment> segments;
 
     optional<gl::VertexBuffer<LineVertex>> vertexBuffer;
-    optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
+    optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
 
 private:
     struct TriangleElement {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index d9e7f9fd35..a09e3b73fc 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -41,30 +41,44 @@ namespace mbgl {
 
 using namespace style;
 
-Painter::Painter(gl::Context& context_, const TransformState& state_)
-    : context(context_),
-      state(state_),
-      tileTriangleVertexBuffer(context.createVertexBuffer(std::vector<FillVertex> {{
+static gl::VertexVector<FillVertex, gl::Triangles> tileTriangles() {
+    gl::VertexVector<FillVertex, gl::Triangles> result;
+    result.emplace_back(
             FillAttributes::vertex({ 0,            0 }),
             FillAttributes::vertex({ util::EXTENT, 0 }),
-            FillAttributes::vertex({ 0, util::EXTENT }),
-            FillAttributes::vertex({ util::EXTENT, 0 }),
-            FillAttributes::vertex({ 0, util::EXTENT }),
-            FillAttributes::vertex({ util::EXTENT, util::EXTENT })
-      }})),
-      tileLineStripVertexBuffer(context.createVertexBuffer(std::vector<FillVertex> {{
-            FillAttributes::vertex({ 0, 0 }),
+            FillAttributes::vertex({ 0, util::EXTENT }));
+    result.emplace_back(
             FillAttributes::vertex({ util::EXTENT, 0 }),
-            FillAttributes::vertex({ util::EXTENT, util::EXTENT }),
             FillAttributes::vertex({ 0, util::EXTENT }),
-            FillAttributes::vertex({ 0, 0 })
-      }})),
-      rasterVertexBuffer(context.createVertexBuffer(std::vector<RasterVertex> {{
-            RasterProgram::vertex({ 0, 0 }, { 0, 0 }),
-            RasterProgram::vertex({ util::EXTENT, 0 }, { 32767, 0 }),
-            RasterProgram::vertex({ 0, util::EXTENT }, { 0, 32767 }),
-            RasterProgram::vertex({ util::EXTENT, util::EXTENT }, { 32767, 32767 })
-      }})) {
+            FillAttributes::vertex({ util::EXTENT, util::EXTENT }));
+    return result;
+}
+
+static gl::VertexVector<FillVertex, gl::LineStrip> tileLineStrip() {
+    gl::VertexVector<FillVertex, gl::LineStrip> result;
+    result.emplace_back(FillAttributes::vertex({ 0, 0 }));
+    result.emplace_back(FillAttributes::vertex({ util::EXTENT, 0 }));
+    result.emplace_back(FillAttributes::vertex({ util::EXTENT, util::EXTENT }));
+    result.emplace_back(FillAttributes::vertex({ 0, util::EXTENT }));
+    result.emplace_back(FillAttributes::vertex({ 0, 0 }));
+    return result;
+}
+
+static gl::VertexVector<RasterVertex, gl::TriangleStrip> rasterTriangleStrip() {
+    gl::VertexVector<RasterVertex, gl::TriangleStrip> result;
+    result.emplace_back(RasterProgram::vertex({ 0, 0 }, { 0, 0 }));
+    result.emplace_back(RasterProgram::vertex({ util::EXTENT, 0 }, { 32767, 0 }));
+    result.emplace_back(RasterProgram::vertex({ 0, util::EXTENT }, { 0, 32767 }));
+    result.emplace_back(RasterProgram::vertex({ util::EXTENT, util::EXTENT }, { 32767, 32767 }));
+    return result;
+}
+
+Painter::Painter(gl::Context& context_, const TransformState& state_)
+    : context(context_),
+      state(state_),
+      tileTriangleVertexBuffer(context.createVertexBuffer(tileTriangles())),
+      tileLineStripVertexBuffer(context.createVertexBuffer(tileLineStrip())),
+      rasterVertexBuffer(context.createVertexBuffer(rasterTriangleStrip())) {
 #ifndef NDEBUG
     gl::debugging::enable();
 #endif
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 53215c5033..3f5f28dad1 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -156,9 +156,9 @@ private:
     std::unique_ptr<Programs> overdrawPrograms;
 #endif
 
-    gl::VertexBuffer<FillVertex> tileTriangleVertexBuffer;
-    gl::VertexBuffer<FillVertex> tileLineStripVertexBuffer;
-    gl::VertexBuffer<RasterVertex> rasterVertexBuffer;
+    gl::VertexBuffer<FillVertex, gl::Triangles> tileTriangleVertexBuffer;
+    gl::VertexBuffer<FillVertex, gl::LineStrip> tileLineStripVertexBuffer;
+    gl::VertexBuffer<RasterVertex, gl::TriangleStrip> rasterVertexBuffer;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index 3e2597e47c..5e71cb7b20 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -28,11 +28,12 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye
         spriteAtlas->bind(true, context, 0);
 
         for (const auto& tileID : util::tileCover(state, state.getIntegerZoom())) {
-            context.draw({
+            parameters.programs.fillPattern.draw(
+                context,
+                gl::Triangles(),
                 depthModeForSublayer(0, gl::DepthMode::ReadOnly),
                 gl::StencilMode::disabled(),
                 colorModeForRenderPass(),
-                parameters.programs.fillPattern,
                 FillPatternUniforms::values(
                     matrixForTile(tileID),
                     properties.backgroundOpacity.value,
@@ -43,16 +44,17 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye
                     tileID,
                     state
                 ),
-                gl::Unindexed<gl::TriangleStrip>(tileTriangleVertexBuffer)
-            });
+                tileTriangleVertexBuffer
+            );
         }
     } else {
         for (const auto& tileID : util::tileCover(state, state.getIntegerZoom())) {
-            context.draw({
+            parameters.programs.fill.draw(
+                context,
+                gl::Triangles(),
                 depthModeForSublayer(0, gl::DepthMode::ReadOnly),
                 gl::StencilMode::disabled(),
                 colorModeForRenderPass(),
-                parameters.programs.fill,
                 FillProgram::UniformValues {
                     uniforms::u_matrix::Value{ matrixForTile(tileID) },
                     uniforms::u_opacity::Value{ properties.backgroundOpacity.value },
@@ -60,8 +62,8 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye
                     uniforms::u_outline_color::Value{ properties.backgroundColor.value },
                     uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
                 },
-                gl::Unindexed<gl::TriangleStrip>(tileTriangleVertexBuffer)
-            });
+                tileTriangleVertexBuffer
+            );
         }
     }
 }
diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp
index e4977b8abb..e9c828bcd8 100644
--- a/src/mbgl/renderer/painter_circle.cpp
+++ b/src/mbgl/renderer/painter_circle.cpp
@@ -23,13 +23,14 @@ void Painter::renderCircle(PaintParameters& parameters,
     const CirclePaintProperties& properties = layer.impl->paint;
     const bool scaleWithMap = properties.circlePitchScale.value == CirclePitchScaleType::Map;
 
-    context.draw({
+    parameters.programs.circle.draw(
+        context,
+        gl::Triangles(),
         depthModeForSublayer(0, gl::DepthMode::ReadOnly),
         frame.mapMode == MapMode::Still
             ? stencilModeForClipping(tile.clip)
             : gl::StencilMode::disabled(),
         colorModeForRenderPass(),
-        parameters.programs.circle,
         CircleProgram::UniformValues {
             uniforms::u_matrix::Value{ tile.translatedMatrix(properties.circleTranslate.value,
                                        properties.circleTranslateAnchor.value,
@@ -47,12 +48,10 @@ void Painter::renderCircle(PaintParameters& parameters,
                 : pixelsToGLUnits },
             uniforms::u_devicepixelratio::Value{ frame.pixelRatio },
         },
-        gl::Segmented<gl::Triangles>(
-            *bucket.vertexBuffer,
-            *bucket.indexBuffer,
-            bucket.segments
-        )
-    });
+        *bucket.vertexBuffer,
+        *bucket.indexBuffer,
+        bucket.segments
+    );
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index b64c5d5efc..2054424475 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -6,7 +6,9 @@
 namespace mbgl {
 
 void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& clip) {
-    context.draw({
+    programs->fill.draw(
+        context,
+        gl::Triangles(),
         gl::DepthMode::disabled(),
         gl::StencilMode {
             gl::StencilMode::Always(),
@@ -17,7 +19,6 @@ void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& cl
             gl::StencilMode::Replace
         },
         gl::ColorMode::disabled(),
-        programs->fill,
         FillProgram::UniformValues {
             uniforms::u_matrix::Value{ matrixForTile(tileID) },
             uniforms::u_opacity::Value{ 0.0f },
@@ -25,8 +26,8 @@ void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& cl
             uniforms::u_outline_color::Value{ Color {} },
             uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
         },
-        gl::Unindexed<gl::Triangles>(tileTriangleVertexBuffer)
-    });
+        tileTriangleVertexBuffer
+    );
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index a0fc98b8c1..8969354d23 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -18,21 +18,19 @@ void Painter::renderTileDebug(const RenderTile& renderTile) {
 
     MBGL_DEBUG_GROUP(std::string { "debug " } + util::toString(renderTile.id));
 
-    auto draw = [&] (Color color, auto subject) {
-        context.draw({
+    auto draw = [&] (Color color, const auto& vertexBuffer, auto drawMode) {
+        programs->debug.draw(
+            context,
+            drawMode,
             gl::DepthMode::disabled(),
             stencilModeForClipping(renderTile.clip),
             gl::ColorMode::unblended(),
-            programs->fill,
-            FillProgram::UniformValues {
+            DebugProgram::UniformValues {
                 uniforms::u_matrix::Value{ renderTile.matrix },
-                uniforms::u_opacity::Value{ 1.0f },
-                uniforms::u_color::Value{ color },
-                uniforms::u_outline_color::Value{ color },
-                uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
+                uniforms::u_color::Value{ color }
             },
-            subject
-        });
+            vertexBuffer
+        );
     };
 
     if (frame.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
@@ -47,15 +45,12 @@ void Painter::renderTileDebug(const RenderTile& renderTile) {
                 tile.expires, frame.debugOptions, context);
         }
 
-        const auto& vertexBuffer = tile.debugBucket->vertexBuffer;
-
-        draw(Color::white(), gl::Unindexed<gl::Lines>(vertexBuffer, 4.0f * frame.pixelRatio));
-        draw(Color::black(), gl::Unindexed<gl::Points>(vertexBuffer, 2.0f));
-        draw(Color::black(), gl::Unindexed<gl::Lines>(vertexBuffer, 2.0f * frame.pixelRatio));
+        draw(Color::white(), tile.debugBucket->vertexBuffer, gl::Lines { 4.0f * frame.pixelRatio });
+        draw(Color::black(), tile.debugBucket->vertexBuffer, gl::Lines { 2.0f * frame.pixelRatio });
     }
 
     if (frame.debugOptions & MapDebugOptions::TileBorders) {
-        draw(Color::red(), gl::Unindexed<gl::LineStrip>(tileLineStripVertexBuffer, 4.0f * frame.pixelRatio));
+        draw(Color::red(), tileLineStripVertexBuffer, gl::LineStrip { 4.0f * frame.pixelRatio });
     }
 }
 
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index cdce181e1c..e5a536fde3 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -35,12 +35,18 @@ void Painter::renderFill(PaintParameters& parameters,
 
         spriteAtlas->bind(true, context, 0);
 
-        auto draw = [&] (uint8_t sublayer, auto& program, const auto& subject) {
-            context.draw({
+        auto draw = [&] (uint8_t sublayer,
+                         auto& program,
+                         const auto& drawMode,
+                         const auto& vertexBuffer,
+                         const auto& indexBuffer,
+                         const auto& segments) {
+            program.draw(
+                context,
+                drawMode,
                 depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite),
                 stencilModeForClipping(tile.clip),
                 colorModeForRenderPass(),
-                program,
                 FillPatternUniforms::values(
                     tile.translatedMatrix(properties.fillTranslate.value,
                                           properties.fillTranslateAnchor.value,
@@ -53,16 +59,18 @@ void Painter::renderFill(PaintParameters& parameters,
                     tile.id,
                     state
                 ),
-                subject
-            });
+                vertexBuffer,
+                indexBuffer,
+                segments
+            );
         };
 
         draw(0,
              parameters.programs.fillPattern,
-             gl::Segmented<gl::Triangles>(
-                 *bucket.vertexBuffer,
-                 *bucket.triangleIndexBuffer,
-                 bucket.triangleSegments));
+             gl::Triangles(),
+             *bucket.vertexBuffer,
+             *bucket.triangleIndexBuffer,
+             bucket.triangleSegments);
 
         if (!properties.fillAntialias.value || !properties.fillOutlineColor.isUndefined()) {
             return;
@@ -70,18 +78,24 @@ void Painter::renderFill(PaintParameters& parameters,
 
         draw(2,
              parameters.programs.fillOutlinePattern,
-             gl::Segmented<gl::Lines>(
-                 *bucket.vertexBuffer,
-                 *bucket.lineIndexBuffer,
-                 bucket.lineSegments,
-                 2.0f));
+             gl::Lines { 2.0f },
+             *bucket.vertexBuffer,
+             *bucket.lineIndexBuffer,
+             bucket.lineSegments);
     } else {
-        auto draw = [&] (uint8_t sublayer, auto& program, Color outlineColor, const auto& subject) {
-            context.draw({
+        auto draw = [&] (uint8_t sublayer,
+                         auto& program,
+                         Color outlineColor,
+                         const auto& drawMode,
+                         const auto& vertexBuffer,
+                         const auto& indexBuffer,
+                         const auto& segments) {
+            program.draw(
+                context,
+                drawMode,
                 depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite),
                 stencilModeForClipping(tile.clip),
                 colorModeForRenderPass(),
-                program,
                 FillProgram::UniformValues {
                     uniforms::u_matrix::Value{ tile.translatedMatrix(properties.fillTranslate.value,
                                                properties.fillTranslateAnchor.value,
@@ -91,19 +105,20 @@ void Painter::renderFill(PaintParameters& parameters,
                     uniforms::u_outline_color::Value{ outlineColor },
                     uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
                 },
-                subject
-            });
+                vertexBuffer,
+                indexBuffer,
+                segments
+            );
         };
 
         if (properties.fillAntialias.value && !properties.fillOutlineColor.isUndefined() && pass == RenderPass::Translucent) {
             draw(2,
                  parameters.programs.fillOutline,
                  properties.fillOutlineColor.value,
-                 gl::Segmented<gl::Lines>(
-                     *bucket.vertexBuffer,
-                     *bucket.lineIndexBuffer,
-                     bucket.lineSegments,
-                     2.0f));
+                 gl::Lines { 2.0f },
+                 *bucket.vertexBuffer,
+                 *bucket.lineIndexBuffer,
+                 bucket.lineSegments);
         }
 
         // Only draw the fill when it's opaque and we're drawing opaque fragments,
@@ -112,21 +127,20 @@ void Painter::renderFill(PaintParameters& parameters,
             draw(1,
                  parameters.programs.fill,
                  properties.fillOutlineColor.value,
-                 gl::Segmented<gl::Triangles>(
-                     *bucket.vertexBuffer,
-                     *bucket.triangleIndexBuffer,
-                     bucket.triangleSegments));
+                 gl::Triangles(),
+                 *bucket.vertexBuffer,
+                 *bucket.triangleIndexBuffer,
+                 bucket.triangleSegments);
         }
 
         if (properties.fillAntialias.value && properties.fillOutlineColor.isUndefined() && pass == RenderPass::Translucent) {
             draw(2,
                  parameters.programs.fillOutline,
                  properties.fillColor.value,
-                 gl::Segmented<gl::Lines>(
-                     *bucket.vertexBuffer,
-                     *bucket.lineIndexBuffer,
-                     bucket.lineSegments,
-                     2.0f));
+                 gl::Lines { 2.0f },
+                 *bucket.vertexBuffer,
+                 *bucket.lineIndexBuffer,
+                 bucket.lineSegments);
         }
     }
 }
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index 7f9556fd3f..a495edc428 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -24,18 +24,17 @@ void Painter::renderLine(PaintParameters& parameters,
     const auto& properties = layer.impl->paint;
 
     auto draw = [&] (auto& program, auto&& uniformValues) {
-        context.draw({
+        program.draw(
+            context,
+            gl::Triangles(),
             depthModeForSublayer(0, gl::DepthMode::ReadOnly),
             stencilModeForClipping(tile.clip),
             colorModeForRenderPass(),
-            program,
             std::move(uniformValues),
-            gl::Segmented<gl::Triangles>(
-                *bucket.vertexBuffer,
-                *bucket.indexBuffer,
-                bucket.segments
-            )
-        });
+            *bucket.vertexBuffer,
+            *bucket.indexBuffer,
+            bucket.segments
+        );
     };
 
     if (!properties.lineDasharray.value.from.empty()) {
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index c619cad2aa..e19cde289a 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -54,11 +54,12 @@ void Painter::renderRaster(PaintParameters& parameters,
     context.bindTexture(*bucket.texture, 0, gl::TextureFilter::Linear);
     context.bindTexture(*bucket.texture, 1, gl::TextureFilter::Linear);
 
-    context.draw({
+    parameters.programs.raster.draw(
+        context,
+        gl::TriangleStrip(),
         depthModeForSublayer(0, gl::DepthMode::ReadOnly),
         gl::StencilMode::disabled(),
         colorModeForRenderPass(),
-        parameters.programs.raster,
         RasterProgram::UniformValues {
             uniforms::u_matrix::Value{ tile.matrix },
             uniforms::u_image0::Value{ 0 },
@@ -74,8 +75,8 @@ void Painter::renderRaster(PaintParameters& parameters,
             uniforms::u_scale_parent::Value{ 1.0f },
             uniforms::u_tl_parent::Value{ std::array<float, 2> {{ 0.0f, 0.0f }} },
         },
-        gl::Unindexed<gl::TriangleStrip>(rasterVertexBuffer)
-    });
+        rasterVertexBuffer
+    );
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index 2f94544486..d2dee5d99d 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -46,7 +46,9 @@ void Painter::renderSymbol(PaintParameters& parameters,
         const bool drawAcrossEdges = (frame.mapMode == MapMode::Continuous) && (true || !(layout.textAllowOverlap || layout.iconAllowOverlap ||
               layout.textIgnorePlacement || layout.iconIgnorePlacement));
 
-        context.draw({
+        program.draw(
+            context,
+            gl::Triangles(),
             values_.pitchAlignment == AlignmentType::Map
                 ? depthModeForSublayer(0, gl::DepthMode::ReadOnly)
                 : gl::DepthMode::disabled(),
@@ -54,14 +56,11 @@ void Painter::renderSymbol(PaintParameters& parameters,
                 ? gl::StencilMode::disabled()
                 : stencilModeForClipping(tile.clip),
             colorModeForRenderPass(),
-            program,
             std::move(uniformValues),
-            gl::Segmented<gl::Triangles>(
-                *buffers.vertexBuffer,
-                *buffers.indexBuffer,
-                buffers.segments
-            )
-        });
+            *buffers.vertexBuffer,
+            *buffers.indexBuffer,
+            buffers.segments
+        );
     };
 
     if (bucket.hasIconData()) {
@@ -119,22 +118,20 @@ void Painter::renderSymbol(PaintParameters& parameters,
     }
 
     if (bucket.hasCollisionBoxData()) {
-        context.draw({
+        programs->collisionBox.draw(
+            context,
+            gl::Lines { 1.0f },
             gl::DepthMode::disabled(),
             gl::StencilMode::disabled(),
             colorModeForRenderPass(),
-            programs->collisionBox,
             CollisionBoxProgram::UniformValues {
                 uniforms::u_matrix::Value{ tile.matrix },
                 uniforms::u_scale::Value{ std::pow(2.0f, float(state.getZoom() - tile.tile.id.overscaledZ)) },
                 uniforms::u_zoom::Value{ float(state.getZoom() * 10) },
                 uniforms::u_maxzoom::Value{ float((tile.id.canonical.z + 1) * 10) },
             },
-            gl::Unindexed<gl::Lines>(
-                *bucket.collisionBox.vertexBuffer,
-                1.0f
-            )
-        });
+            *bucket.collisionBox.vertexBuffer
+        );
     }
 }
 
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index d33341008e..f1fc3d324e 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -34,26 +34,26 @@ public:
     const bool iconsNeedLinear;
 
     struct TextBuffer {
-        std::vector<SymbolVertex> vertices;
-        std::vector<gl::Triangle> triangles;
+        gl::VertexVector<SymbolVertex> vertices;
+        gl::IndexVector<gl::Triangles> triangles;
         std::vector<gl::Segment> segments;
 
         optional<gl::VertexBuffer<SymbolVertex>> vertexBuffer;
-        optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
+        optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
     } text;
 
     struct IconBuffer {
-        std::vector<SymbolVertex> vertices;
-        std::vector<gl::Triangle> triangles;
+        gl::VertexVector<SymbolVertex> vertices;
+        gl::IndexVector<gl::Triangles> triangles;
         std::vector<gl::Segment> segments;
 
         optional<gl::VertexBuffer<SymbolVertex>> vertexBuffer;
-        optional<gl::IndexBuffer<gl::Triangle>> indexBuffer;
+        optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
     } icon;
 
     struct CollisionBoxBuffer {
-        std::vector<CollisionBoxVertex> vertices;
-        optional<gl::VertexBuffer<CollisionBoxVertex>> vertexBuffer;
+        gl::VertexVector<CollisionBoxVertex, gl::Lines> vertices;
+        optional<gl::VertexBuffer<CollisionBoxVertex, gl::Lines>> vertexBuffer;
     } collisionBox;
 };