[core] Introduce PaintParameters

Use it to DRY selection of regular vs. overdraw shaders and VAOs.

22 files changed, 105 insertions, 76 deletions

diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index 4fcfb7b24e..5575b96176 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -12,6 +12,7 @@
 namespace mbgl {
 
 class Painter;
+class PaintParameters;
 class UnwrappedTileID;
 class CollisionTile;
 
@@ -34,7 +35,7 @@ public:
 
     // Every time this bucket is getting rendered, this function is called. This happens either
     // once or twice (for Opaque and Transparent render passes).
-    virtual void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) = 0;
+    virtual void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) = 0;
 
     virtual ~Bucket() = default;
 
diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp
index 3a6181b003..d0d2d2402e 100644
--- a/src/mbgl/renderer/circle_bucket.cpp
+++ b/src/mbgl/renderer/circle_bucket.cpp
@@ -23,10 +23,11 @@ void CircleBucket::upload(gl::ObjectStore& store, gl::Config&) {
 }
 
 void CircleBucket::render(Painter& painter,
+                        PaintParameters& parameters, 
                         const Layer& layer,
                         const UnwrappedTileID& tileID,
                         const mat4& matrix) {
-    painter.renderCircle(*this, *layer.as<CircleLayer>(), tileID, matrix);
+    painter.renderCircle(parameters, *this, *layer.as<CircleLayer>(), tileID, matrix);
 }
 
 bool CircleBucket::hasData() const {
diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp
index 695abe53b6..81d8161b06 100644
--- a/src/mbgl/renderer/circle_bucket.hpp
+++ b/src/mbgl/renderer/circle_bucket.hpp
@@ -19,7 +19,7 @@ public:
     ~CircleBucket() override;
 
     void upload(gl::ObjectStore&, gl::Config&) override;
-    void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
+    void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
 
     bool hasData() const override;
     bool needsClipping() const override;
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index e79dfd316b..1ec53ee510 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -105,10 +105,11 @@ void FillBucket::upload(gl::ObjectStore& store, gl::Config&) {
 }
 
 void FillBucket::render(Painter& painter,
+                        PaintParameters& parameters,
                         const Layer& layer,
                         const UnwrappedTileID& tileID,
                         const mat4& matrix) {
-    painter.renderFill(*this, *layer.as<FillLayer>(), tileID, matrix);
+    painter.renderFill(parameters, *this, *layer.as<FillLayer>(), tileID, matrix);
 }
 
 bool FillBucket::hasData() const {
diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp
index 69d4331486..c95efba1ca 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -21,7 +21,7 @@ public:
     ~FillBucket() override;
 
     void upload(gl::ObjectStore&, gl::Config&) override;
-    void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
+    void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
 
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 381356b801..0f3a31c272 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -446,10 +446,11 @@ void LineBucket::upload(gl::ObjectStore& store, gl::Config&) {
 }
 
 void LineBucket::render(Painter& painter,
+                        PaintParameters& parameters,
                         const Layer& layer,
                         const UnwrappedTileID& tileID,
                         const mat4& matrix) {
-    painter.renderLine(*this, *layer.as<LineLayer>(), tileID, matrix);
+    painter.renderLine(parameters, *this, *layer.as<LineLayer>(), tileID, matrix);
 }
 
 bool LineBucket::hasData() const {
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index f09341e7a5..49b6211070 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -25,7 +25,7 @@ public:
     ~LineBucket() override;
 
     void upload(gl::ObjectStore&, gl::Config&) override;
-    void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
+    void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
 
diff --git a/src/mbgl/renderer/paint_parameters.hpp b/src/mbgl/renderer/paint_parameters.hpp
new file mode 100644
index 0000000000..13bf21080d
--- /dev/null
+++ b/src/mbgl/renderer/paint_parameters.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace mbgl {
+
+class Shaders;
+
+class PaintParameters {
+public:
+    Shaders& shaders;
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 2b82983d27..e55f41b5fb 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 
 #include <mbgl/style/source.hpp>
@@ -67,6 +68,10 @@ void Painter::setClipping(const ClipID& clip) {
 void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& annotationSpriteAtlas) {
     frame = frame_;
 
+    PaintParameters parameters {
+        isOverdraw() ? *overdrawShaders : *shaders
+    };
+
     glyphAtlas = style.glyphAtlas.get();
     spriteAtlas = style.spriteAtlas.get();
     lineAtlas = style.lineAtlas.get();
@@ -150,7 +155,7 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
             source->baseImpl->startRender(generator, projMatrix, state);
         }
 
-        drawClippingMasks(generator.getStencils());
+        drawClippingMasks(parameters, generator.getStencils());
     }
 
     if (frame.debugOptions & MapDebugOptions::StencilClip) {
@@ -166,13 +171,15 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
 
     // - OPAQUE PASS -------------------------------------------------------------------------------
     // Render everything top-to-bottom by using reverse iterators. Render opaque objects first.
-    renderPass(RenderPass::Opaque,
+    renderPass(parameters,
+               RenderPass::Opaque,
                order.rbegin(), order.rend(),
                0, 1);
 
     // - TRANSLUCENT PASS --------------------------------------------------------------------------
     // Make a second pass, rendering translucent objects. This time, we render bottom-to-top.
-    renderPass(RenderPass::Translucent,
+    renderPass(parameters,
+               RenderPass::Translucent,
                order.begin(), order.end(),
                static_cast<GLsizei>(order.size()) - 1, -1);
 
@@ -211,7 +218,8 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
 }
 
 template <class Iterator>
-void Painter::renderPass(RenderPass pass_,
+void Painter::renderPass(PaintParameters& parameters,
+                         RenderPass pass_,
                          Iterator it, Iterator end,
                          GLsizei i, int8_t increment) {
     pass = pass_;
@@ -246,7 +254,7 @@ void Painter::renderPass(RenderPass pass_,
 
         if (layer.is<BackgroundLayer>()) {
             MBGL_DEBUG_GROUP("background");
-            renderBackground(*layer.as<BackgroundLayer>());
+            renderBackground(parameters, *layer.as<BackgroundLayer>());
         } else if (layer.is<CustomLayer>()) {
             MBGL_DEBUG_GROUP(layer.baseImpl->id + " - custom");
             VertexArrayObject::Unbind();
@@ -257,7 +265,7 @@ void Painter::renderPass(RenderPass pass_,
             if (item.bucket->needsClipping()) {
                 setClipping(item.tile->clip);
             }
-            item.bucket->render(*this, layer, item.tile->id, item.tile->matrix);
+            item.bucket->render(*this, parameters, layer, item.tile->id, item.tile->matrix);
         }
     }
 
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index dc8e2b7fca..4c13d9dcd5 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -43,6 +43,7 @@ class RasterBucket;
 
 class Shaders;
 class SDFShader;
+class PaintParameters;
 
 struct ClipID;
 
@@ -88,18 +89,18 @@ public:
     void renderClipMasks();
 
     void renderDebugText(Tile&, const mat4&);
-    void renderFill(FillBucket&, const style::FillLayer&, const UnwrappedTileID&, const mat4&);
-    void renderLine(LineBucket&, const style::LineLayer&, const UnwrappedTileID&, const mat4&);
-    void renderCircle(CircleBucket&, const style::CircleLayer&, const UnwrappedTileID&, const mat4&);
-    void renderSymbol(SymbolBucket&, const style::SymbolLayer&, const UnwrappedTileID&, const mat4&);
-    void renderRaster(RasterBucket&, const style::RasterLayer&, const UnwrappedTileID&, const mat4&);
-    void renderBackground(const style::BackgroundLayer&);
+    void renderFill(PaintParameters&, FillBucket&, const style::FillLayer&, const UnwrappedTileID&, const mat4&);
+    void renderLine(PaintParameters&, LineBucket&, const style::LineLayer&, const UnwrappedTileID&, const mat4&);
+    void renderCircle(PaintParameters&, CircleBucket&, const style::CircleLayer&, const UnwrappedTileID&, const mat4&);
+    void renderSymbol(PaintParameters&, SymbolBucket&, const style::SymbolLayer&, const UnwrappedTileID&, const mat4&);
+    void renderRaster(PaintParameters&, RasterBucket&, const style::RasterLayer&, const UnwrappedTileID&, const mat4&);
+    void renderBackground(PaintParameters&, const style::BackgroundLayer&);
 
     float saturationFactor(float saturation);
     float contrastFactor(float contrast);
     std::array<float, 3> spinWeights(float spin_value);
 
-    void drawClippingMasks(const std::map<UnwrappedTileID, ClipID>&);
+    void drawClippingMasks(PaintParameters&, const std::map<UnwrappedTileID, ClipID>&);
 
     bool needsAnimation() const;
 
@@ -112,7 +113,8 @@ private:
     std::vector<RenderItem> determineRenderOrder(const style::Style&);
 
     template <class Iterator>
-    void renderPass(RenderPass,
+    void renderPass(PaintParameters&,
+                    RenderPass,
                     Iterator it, Iterator end,
                     GLsizei i, int8_t increment);
 
@@ -209,16 +211,6 @@ private:
         {{ util::EXTENT, util::EXTENT, 32767, 32767 }},
     };
 
-    VertexArrayObject coveringPlainArray;
-    VertexArrayObject coveringRasterArray;
-    VertexArrayObject backgroundPatternArray;
-    VertexArrayObject backgroundArray;
-
-    VertexArrayObject coveringPlainOverdrawArray;
-    VertexArrayObject coveringRasterOverdrawArray;
-    VertexArrayObject backgroundPatternOverdrawArray;
-    VertexArrayObject backgroundOverdrawArray;
-
     // Set up the tile boundary lines we're using to draw the tile outlines.
     StaticVertexBuffer tileBorderBuffer {
         {{ 0, 0 }},
diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index e2fb4db494..51a892575b 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
@@ -11,7 +12,7 @@ namespace mbgl {
 
 using namespace style;
 
-void Painter::renderBackground(const BackgroundLayer& layer) {
+void Painter::renderBackground(PaintParameters& parameters, const BackgroundLayer& layer) {
     // Note that for bottommost layers without a pattern, the background color is drawn with
     // glClear rather than this method.
     const BackgroundPaintProperties& properties = layer.impl->paint;
@@ -20,11 +21,10 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
     optional<SpriteAtlasPosition> imagePosA;
     optional<SpriteAtlasPosition> imagePosB;
 
-    const bool overdraw = isOverdraw();
-    auto& patternShader = overdraw ? overdrawShaders->pattern : shaders->pattern;
-    auto& plainShader = overdraw ? overdrawShaders->plain : shaders->plain;
-    auto& arrayBackgroundPattern = overdraw ? backgroundPatternOverdrawArray : backgroundPatternArray;
-    auto& arrayBackground = overdraw ? backgroundOverdrawArray : backgroundArray;
+    auto& patternShader = parameters.shaders.pattern;
+    auto& plainShader = parameters.shaders.plain;
+    auto& arrayBackgroundPattern = parameters.shaders.backgroundPatternArray;
+    auto& arrayBackground = parameters.shaders.backgroundArray;
 
     if (isPatterned) {
         imagePosA = spriteAtlas->getPosition(properties.backgroundPattern.value.from, true);
diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp
index 19cdbaf8f7..089c2e15ea 100644
--- a/src/mbgl/renderer/painter_circle.cpp
+++ b/src/mbgl/renderer/painter_circle.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/circle_bucket.hpp>
 
 #include <mbgl/style/layers/circle_layer.hpp>
@@ -10,7 +11,8 @@ namespace mbgl {
 
 using namespace style;
 
-void Painter::renderCircle(CircleBucket& bucket,
+void Painter::renderCircle(PaintParameters& parameters,
+                           CircleBucket& bucket,
                            const CircleLayer& layer,
                            const UnwrappedTileID& tileID,
                            const mat4& matrix) {
@@ -27,7 +29,7 @@ void Painter::renderCircle(CircleBucket& bucket,
     mat4 vtxMatrix = translatedMatrix(matrix, properties.circleTranslate, tileID,
                                       properties.circleTranslateAnchor);
 
-    auto& circleShader = isOverdraw() ? overdrawShaders->circle : shaders->circle;
+    auto& circleShader = parameters.shaders.circle;
 
     config.program = circleShader.getID();
 
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index f67c12b929..7cb8e01c57 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/style/source.hpp>
 #include <mbgl/shader/shaders.hpp>
 #include <mbgl/util/clip_id.hpp>
@@ -8,12 +9,11 @@
 namespace mbgl {
 
 
-void Painter::drawClippingMasks(const std::map<UnwrappedTileID, ClipID>& stencils) {
+void Painter::drawClippingMasks(PaintParameters& parameters, const std::map<UnwrappedTileID, ClipID>& stencils) {
     MBGL_DEBUG_GROUP("clipping masks");
 
-    const bool overdraw = isOverdraw();
-    auto& plainShader = overdraw ? overdrawShaders->plain : shaders->plain;
-    auto& arrayCoveringPlain = overdraw ? coveringPlainOverdrawArray : coveringPlainArray;
+    auto& plainShader = parameters.shaders.plain;
+    auto& arrayCoveringPlain = parameters.shaders.coveringPlainArray;
 
     mat4 matrix;
     const GLuint mask = 0b11111111;
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index 034f84d8fc..1b10a90b0b 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/fill_bucket.hpp>
 #include <mbgl/style/layers/fill_layer.hpp>
 #include <mbgl/style/layers/fill_layer_impl.hpp>
@@ -10,7 +11,8 @@ namespace mbgl {
 
 using namespace style;
 
-void Painter::renderFill(FillBucket& bucket,
+void Painter::renderFill(PaintParameters& parameters,
+                         FillBucket& bucket,
                          const FillLayer& layer,
                          const UnwrappedTileID& tileID,
                          const mat4& matrix) {
@@ -40,11 +42,10 @@ void Painter::renderFill(FillBucket& bucket,
     config.depthMask = GL_TRUE;
     config.lineWidth = 2.0f; // This is always fixed and does not depend on the pixelRatio!
 
-    const bool overdraw = isOverdraw();
-    auto& outlineShader = overdraw ? overdrawShaders->outline : shaders->outline;
-    auto& patternShader = overdraw ? overdrawShaders->pattern : shaders->pattern;
-    auto& outlinePatternShader = overdraw ? overdrawShaders->outlinePattern : shaders->outlinePattern;
-    auto& plainShader = overdraw ? overdrawShaders->plain : shaders->plain;
+    auto& outlineShader = parameters.shaders.outline;
+    auto& patternShader = parameters.shaders.pattern;
+    auto& outlinePatternShader = parameters.shaders.outlinePattern;
+    auto& plainShader = parameters.shaders.plain;
 
     // Because we're drawing top-to-bottom, and we update the stencil mask
     // befrom, we have to draw the outline first (!)
@@ -70,7 +71,7 @@ void Painter::renderFill(FillBucket& bucket,
             // the (non-antialiased) fill.
             setDepthSublayer(0); // OK
         }
-        bucket.drawVertices(outlineShader, store, overdraw);
+        bucket.drawVertices(outlineShader, store, isOverdraw());
     }
 
     if (pattern) {
@@ -104,7 +105,7 @@ void Painter::renderFill(FillBucket& bucket,
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(0);
-            bucket.drawElements(patternShader, store, overdraw);
+            bucket.drawElements(patternShader, store, isOverdraw());
 
             if (properties.fillAntialias && !isOutlineColorDefined) {
                 config.program = outlinePatternShader.getID();
@@ -131,7 +132,7 @@ void Painter::renderFill(FillBucket& bucket,
                 spriteAtlas->bind(true, store, config, 0);
 
                 setDepthSublayer(2);
-                bucket.drawVertices(outlinePatternShader, store, overdraw);
+                bucket.drawVertices(outlinePatternShader, store, isOverdraw());
             }
         }
     } else {
@@ -148,7 +149,7 @@ void Painter::renderFill(FillBucket& bucket,
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(1);
-            bucket.drawElements(plainShader, store, overdraw);
+            bucket.drawElements(plainShader, store, isOverdraw());
         }
     }
 
@@ -165,7 +166,7 @@ void Painter::renderFill(FillBucket& bucket,
         outlineShader.u_world = worldSize;
 
         setDepthSublayer(2);
-        bucket.drawVertices(outlineShader, store, overdraw);
+        bucket.drawVertices(outlineShader, store, isOverdraw());
     }
 }
 
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index d2e6c4c29a..eece09a249 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/line_bucket.hpp>
 #include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
@@ -11,7 +12,8 @@ namespace mbgl {
 
 using namespace style;
 
-void Painter::renderLine(LineBucket& bucket,
+void Painter::renderLine(PaintParameters& parameters,
+                         LineBucket& bucket,
                          const LineLayer& layer,
                          const UnwrappedTileID& tileID,
                          const mat4& matrix) {
@@ -53,10 +55,9 @@ void Painter::renderLine(LineBucket& bucket,
 
     setDepthSublayer(0);
 
-    const bool overdraw = isOverdraw();
-    auto& linesdfShader = overdraw ? overdrawShaders->linesdf : shaders->linesdf;
-    auto& linepatternShader = overdraw ? overdrawShaders->linepattern : shaders->linepattern;
-    auto& lineShader = overdraw ? overdrawShaders->line : shaders->line;
+    auto& linesdfShader = parameters.shaders.linesdf;
+    auto& linepatternShader = parameters.shaders.linepattern;
+    auto& lineShader = parameters.shaders.line;
 
     if (!properties.lineDasharray.value.from.empty()) {
         config.program = linesdfShader.getID();
@@ -94,7 +95,7 @@ void Painter::renderLine(LineBucket& bucket,
         linesdfShader.u_image = 0;
         lineAtlas->bind(store, config, 0);
 
-        bucket.drawLineSDF(linesdfShader, store, overdraw);
+        bucket.drawLineSDF(linesdfShader, store, isOverdraw());
 
     } else if (!properties.linePattern.value.from.empty()) {
         optional<SpriteAtlasPosition> imagePosA = spriteAtlas->getPosition(properties.linePattern.value.from, true);
@@ -135,7 +136,7 @@ void Painter::renderLine(LineBucket& bucket,
         linepatternShader.u_image = 0;
         spriteAtlas->bind(true, store, config, 0);
 
-        bucket.drawLinePatterns(linepatternShader, store, overdraw);
+        bucket.drawLinePatterns(linepatternShader, store, isOverdraw());
 
     } else {
         config.program = lineShader.getID();
@@ -153,7 +154,7 @@ void Painter::renderLine(LineBucket& bucket,
         lineShader.u_color = color;
         lineShader.u_opacity = opacity;
 
-        bucket.drawLines(lineShader, store, overdraw);
+        bucket.drawLines(lineShader, store, isOverdraw());
     }
 }
 
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index aeb5e85879..e71d4c1fe0 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/gl/gl.hpp>
 #include <mbgl/renderer/raster_bucket.hpp>
 #include <mbgl/style/layers/raster_layer.hpp>
@@ -9,7 +10,8 @@ namespace mbgl {
 
 using namespace style;
 
-void Painter::renderRaster(RasterBucket& bucket,
+void Painter::renderRaster(PaintParameters& parameters,
+                           RasterBucket& bucket,
                            const RasterLayer& layer,
                            const UnwrappedTileID&,
                            const mat4& matrix) {
@@ -18,9 +20,8 @@ void Painter::renderRaster(RasterBucket& bucket,
     const RasterPaintProperties& properties = layer.impl->paint;
 
     if (bucket.hasData()) {
-        const bool overdraw = isOverdraw();
-        auto& rasterShader = overdraw ? overdrawShaders->raster : shaders->raster;
-        auto& rasterVAO = overdraw ? coveringRasterOverdrawArray : coveringRasterArray;
+        auto& rasterShader = parameters.shaders.raster;
+        auto& rasterVAO = parameters.shaders.coveringRasterArray;
 
         config.program = rasterShader.getID();
         rasterShader.u_matrix = matrix;
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index d541479b10..6f2d9581eb 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/symbol_bucket.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
@@ -110,7 +111,8 @@ void Painter::renderSDF(SymbolBucket &bucket,
     }
 }
 
-void Painter::renderSymbol(SymbolBucket& bucket,
+void Painter::renderSymbol(PaintParameters& parameters,
+                           SymbolBucket& bucket,
                            const SymbolLayer& layer,
                            const UnwrappedTileID& tileID,
                            const mat4& matrix) {
@@ -169,7 +171,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
                       matrix,
                       1.0f,
                       {{ float(activeSpriteAtlas->getWidth()) / 4.0f, float(activeSpriteAtlas->getHeight()) / 4.0f }},
-                      isOverdraw() ? overdrawShaders->sdfIcon : shaders->sdfIcon,
+                      parameters.shaders.sdfIcon,
                       &SymbolBucket::drawIcons,
                       layout.iconRotationAlignment,
                       // icon-pitch-alignment is not yet implemented
@@ -200,8 +202,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
                 }};
             }
 
-            const bool overdraw = isOverdraw();
-            auto& iconShader = overdraw ? overdrawShaders->icon : shaders->icon;
+            auto& iconShader = parameters.shaders.icon;
 
             config.program = iconShader.getID();
             iconShader.u_matrix = vtxMatrix;
@@ -219,7 +220,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
             iconShader.u_fadetexture = 1;
 
             setDepthSublayer(0);
-            bucket.drawIcons(iconShader, store, overdraw);
+            bucket.drawIcons(iconShader, store, isOverdraw());
         }
     }
 
@@ -238,7 +239,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
                   matrix,
                   24.0f,
                   {{ float(glyphAtlas->width) / 4, float(glyphAtlas->height) / 4 }},
-                  isOverdraw() ? overdrawShaders->sdfGlyph : shaders->sdfGlyph,
+                  parameters.shaders.sdfGlyph,
                   &SymbolBucket::drawGlyphs,
                   layout.textRotationAlignment,
                   layout.textPitchAlignment,
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index c4e11198d3..75540efd1c 100644
--- a/src/mbgl/renderer/raster_bucket.cpp
+++ b/src/mbgl/renderer/raster_bucket.cpp
@@ -15,10 +15,11 @@ void RasterBucket::upload(gl::ObjectStore& store, gl::Config& config) {
 }
 
 void RasterBucket::render(Painter& painter,
+                          PaintParameters& parameters,
                           const Layer& layer,
                           const UnwrappedTileID& tileID,
                           const mat4& matrix) {
-    painter.renderRaster(*this, *layer.as<RasterLayer>(), tileID, matrix);
+    painter.renderRaster(parameters, *this, *layer.as<RasterLayer>(), tileID, matrix);
 }
 
 void RasterBucket::setImage(PremultipliedImage image) {
diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp
index ec24cff400..5cf6e70283 100644
--- a/src/mbgl/renderer/raster_bucket.hpp
+++ b/src/mbgl/renderer/raster_bucket.hpp
@@ -13,7 +13,7 @@ class VertexArrayObject;
 class RasterBucket : public Bucket {
 public:
     void upload(gl::ObjectStore&, gl::Config&) override;
-    void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
+    void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
 
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 78b90dea19..eedf02b2f3 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -87,10 +87,11 @@ void SymbolBucket::upload(gl::ObjectStore& store, gl::Config&) {
 }
 
 void SymbolBucket::render(Painter& painter,
+                          PaintParameters& parameters,
                           const Layer& layer,
                           const UnwrappedTileID& tileID,
                           const mat4& matrix) {
-    painter.renderSymbol(*this, *layer.as<SymbolLayer>(), tileID, matrix);
+    painter.renderSymbol(parameters, *this, *layer.as<SymbolLayer>(), tileID, matrix);
 }
 
 bool SymbolBucket::hasData() const { return hasTextData() || hasIconData() || !symbolInstances.empty(); }
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index 9a023a6010..2185bc79f7 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -70,7 +70,7 @@ public:
     ~SymbolBucket() override;
 
     void upload(gl::ObjectStore&, gl::Config&) override;
-    void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
+    void render(Painter&, PaintParameters&, const style::Layer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool hasTextData() const;
     bool hasIconData() const;
diff --git a/src/mbgl/shader/shaders.hpp b/src/mbgl/shader/shaders.hpp
index 574f71a1c3..088e351d37 100644
--- a/src/mbgl/shader/shaders.hpp
+++ b/src/mbgl/shader/shaders.hpp
@@ -49,6 +49,11 @@ public:
     SDFShader sdfIcon;
     CollisionBoxShader collisionBox;
     CircleShader circle;
+
+    VertexArrayObject coveringPlainArray;
+    VertexArrayObject coveringRasterArray;
+    VertexArrayObject backgroundPatternArray;
+    VertexArrayObject backgroundArray;
 };
 
 } // namespace mbgl