[core] Extract renderTileDebug; inline renderClippingMask

9 files changed, 175 insertions, 266 deletions

diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index f8e297b316..9af511a03e 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -1,27 +1,17 @@
 #pragma once
 
-#include <mbgl/renderer/render_pass.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
-#include <mbgl/renderer/render_layer.hpp>
 
 #include <atomic>
-#include <string>
-#include <unordered_map>
 
 namespace mbgl {
 
-class Painter;
-class PaintParameters;
-class RenderTile;
-
 namespace gl {
 class Context;
 } // namespace gl
 
-namespace style {
-class Layer;
-} // namespace style
+class RenderLayer;
 
 class Bucket : private util::noncopyable {
 public:
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 3835cedd92..78bac8b44c 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -3,35 +3,27 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/render_source.hpp>
 #include <mbgl/renderer/render_style.hpp>
+#include <mbgl/renderer/image_manager.hpp>
+#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
 
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/layer_impl.hpp>
 
 #include <mbgl/map/view.hpp>
-
-#include <mbgl/util/logging.hpp>
 #include <mbgl/gl/debugging.hpp>
-
-#include <mbgl/style/layer_impl.hpp>
-#include <mbgl/style/layers/custom_layer_impl.hpp>
-
 #include <mbgl/tile/tile.hpp>
-#include <mbgl/renderer/layers/render_background_layer.hpp>
-#include <mbgl/renderer/layers/render_custom_layer.hpp>
-#include <mbgl/style/layers/custom_layer_impl.hpp>
-#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
-
-#include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/geometry/line_atlas.hpp>
-
 #include <mbgl/programs/program_parameters.hpp>
 #include <mbgl/programs/programs.hpp>
 
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/mat3.hpp>
 #include <mbgl/util/string.hpp>
-
 #include <mbgl/util/stopwatch.hpp>
+#include <mbgl/util/clip_id.hpp>
+#include <mbgl/util/logging.hpp>
+#include <mbgl/util/color.hpp>
 
 #include <cassert>
 #include <algorithm>
@@ -196,15 +188,66 @@ void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
 
         MBGL_DEBUG_GROUP(context, "clipping masks");
 
+        static const style::FillPaintProperties::PossiblyEvaluated properties {};
+        static const FillProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
+
         for (const auto& clipID : clipIDGenerator.getClipIDs()) {
-            MBGL_DEBUG_GROUP(context, std::string{ "mask: " } + util::toString(clipID.first));
-            renderClippingMask(clipID.first, clipID.second);
+            programs->fill.get(properties).draw(
+                context,
+                gl::Triangles(),
+                gl::DepthMode::disabled(),
+                gl::StencilMode {
+                    gl::StencilMode::Always(),
+                    static_cast<int32_t>(clipID.second.reference.to_ulong()),
+                    0b11111111,
+                    gl::StencilMode::Keep,
+                    gl::StencilMode::Keep,
+                    gl::StencilMode::Replace
+                },
+                gl::ColorMode::disabled(),
+                FillProgram::UniformValues {
+                    uniforms::u_matrix::Value{ matrixForTile(clipID.first) },
+                    uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
+                },
+                tileVertexBuffer,
+                quadTriangleIndexBuffer,
+                tileTriangleSegments,
+                paintAttibuteData,
+                properties,
+                state.getZoom(),
+                "clipping"
+            );
         }
     }
 
 #if not MBGL_USE_GLES2 and not defined(NDEBUG)
+    // Render tile clip boundaries, using stencil buffer to calculate fill color.
     if (frame.debugOptions & MapDebugOptions::StencilClip) {
-        renderClipMasks(parameters);
+        context.setStencilMode(gl::StencilMode::disabled());
+        context.setDepthMode(gl::DepthMode::disabled());
+        context.setColorMode(gl::ColorMode::unblended());
+        context.program = 0;
+
+        // Reset the value in case someone else changed it, or it's dirty.
+        context.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
+
+        // Read the stencil buffer
+        const auto viewport = context.viewport.getCurrentValue();
+        auto image =
+            context.readFramebuffer<AlphaImage, gl::TextureFormat::Stencil>(viewport.size, false);
+
+        // Scale the Stencil buffer to cover the entire color space.
+        auto it = image.data.get();
+        auto end = it + viewport.size.width * viewport.size.height;
+        const auto factor = 255.0f / *std::max_element(it, end);
+        for (; it != end; ++it) {
+            *it *= factor;
+        }
+
+        context.pixelZoom = { 1, 1 };
+        context.rasterPos = { -1, -1, 0, 1 };
+        context.drawPixels(image);
+
         return;
     }
 #endif
@@ -245,8 +288,26 @@ void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
     }
 
 #if not MBGL_USE_GLES2 and not defined(NDEBUG)
+    // Render the depth buffer.
     if (frame.debugOptions & MapDebugOptions::DepthBuffer) {
-        renderDepthBuffer(parameters);
+        context.setStencilMode(gl::StencilMode::disabled());
+        context.setDepthMode(gl::DepthMode::disabled());
+        context.setColorMode(gl::ColorMode::unblended());
+        context.program = 0;
+
+        // Scales the values in the depth buffer so that they cover the entire grayscale range. This
+        // makes it easier to spot tiny differences.
+        const float base = 1.0f / (1.0f - depthRangeSize);
+        context.pixelTransferDepth = { base, 1.0f - base };
+
+        // Read the stencil buffer
+        auto viewport = context.viewport.getCurrentValue();
+        auto image =
+            context.readFramebuffer<AlphaImage, gl::TextureFormat::Depth>(viewport.size, false);
+
+        context.pixelZoom = { 1, 1 };
+        context.rasterPos = { -1, -1, 0, 1 };
+        context.drawPixels(image);
     }
 #endif
 
@@ -288,6 +349,8 @@ void Painter::renderPass(PaintParameters& parameters,
             continue;
 
         if (layer.is<RenderFillExtrusionLayer>()) {
+            MBGL_DEBUG_GROUP(context, item.layer.getID());
+
             const auto size = context.viewport.getCurrentValue().size;
 
             if (!extrusionTexture || extrusionTexture->getSize() != size) {
@@ -300,7 +363,7 @@ void Painter::renderPass(PaintParameters& parameters,
             context.setDepthMode(depthModeForSublayer(0, gl::DepthMode::ReadWrite));
             context.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, 1.0f, {});
 
-            renderItem(parameters, item);
+            item.layer.render(*this, parameters, item.source);
 
             parameters.view.bind();
             context.bindTexture(extrusionTexture->getTexture());
@@ -329,7 +392,8 @@ void Painter::renderPass(PaintParameters& parameters,
                 state.getZoom(),
                 layer.getID());
         } else {
-            renderItem(parameters, item);
+            MBGL_DEBUG_GROUP(context, item.layer.getID());
+            item.layer.render(*this, parameters, item.source);
         }
     }
 
@@ -338,12 +402,6 @@ void Painter::renderPass(PaintParameters& parameters,
     }
 }
 
-void Painter::renderItem(PaintParameters& parameters, const RenderItem& item) {
-    RenderLayer& layer = item.layer;
-    MBGL_DEBUG_GROUP(context, layer.getID());
-    layer.render(*this, parameters, item.source);
-}
-
 mat4 Painter::matrixForTile(const UnwrappedTileID& tileID) {
     mat4 matrix;
     state.matrixFor(matrix, tileID);
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index c9f89aa995..63f38a1fee 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -8,39 +8,31 @@
 #include <mbgl/renderer/render_item.hpp>
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/renderer/render_light.hpp>
+#include <mbgl/renderer/render_pass.hpp>
 
 #include <mbgl/gl/context.hpp>
 #include <mbgl/programs/debug_program.hpp>
-#include <mbgl/programs/program_parameters.hpp>
 #include <mbgl/programs/fill_program.hpp>
 #include <mbgl/programs/extrusion_texture_program.hpp>
 #include <mbgl/programs/raster_program.hpp>
 
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/chrono.hpp>
-#include <mbgl/util/constants.hpp>
 #include <mbgl/util/offscreen_texture.hpp>
 
 #include <mbgl/algorithm/generate_clip_ids.hpp>
 
 #include <array>
 #include <vector>
-#include <set>
-#include <map>
 
 namespace mbgl {
 
 class RenderStyle;
-class RenderTile;
 class ImageManager;
 class View;
 class LineAtlas;
-struct FrameData;
-class Tile;
-class DebugBucket;
 class Programs;
 class PaintParameters;
-class TilePyramid;
 struct ClipID;
 
 struct FrameData {
@@ -61,19 +53,6 @@ public:
                 View&);
 
     void cleanup();
-
-    void renderClippingMask(const UnwrappedTileID&, const ClipID&);
-    void renderTileDebug(const RenderTile&);
-    void renderTileDebug(const mat4& matrix);
-    void renderItem(PaintParameters&, const RenderItem&);
-
-#ifndef NDEBUG
-    // Renders tile clip boundaries, using stencil buffer to calculate fill color.
-    void renderClipMasks(PaintParameters&);
-    // Renders the depth buffer.
-    void renderDepthBuffer(PaintParameters&);
-#endif
-
     bool needsAnimation() const;
 
     template <class Iterator>
diff --git a/src/mbgl/renderer/painters/painter_clipping.cpp b/src/mbgl/renderer/painters/painter_clipping.cpp
deleted file mode 100644
index 025019b5c7..0000000000
--- a/src/mbgl/renderer/painters/painter_clipping.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <mbgl/renderer/painter.hpp>
-#include <mbgl/programs/programs.hpp>
-#include <mbgl/programs/fill_program.hpp>
-#include <mbgl/util/clip_id.hpp>
-
-namespace mbgl {
-
-void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& clip) {
-    static const style::FillPaintProperties::PossiblyEvaluated properties {};
-    static const FillProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
-    programs->fill.get(properties).draw(
-        context,
-        gl::Triangles(),
-        gl::DepthMode::disabled(),
-        gl::StencilMode {
-            gl::StencilMode::Always(),
-            static_cast<int32_t>(clip.reference.to_ulong()),
-            0b11111111,
-            gl::StencilMode::Keep,
-            gl::StencilMode::Keep,
-            gl::StencilMode::Replace
-        },
-        gl::ColorMode::disabled(),
-        FillProgram::UniformValues {
-            uniforms::u_matrix::Value{ matrixForTile(tileID) },
-            uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
-        },
-        tileVertexBuffer,
-        quadTriangleIndexBuffer,
-        tileTriangleSegments,
-        paintAttibuteData,
-        properties,
-        state.getZoom(),
-        "clipping"
-    );
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/renderer/painters/painter_debug.cpp b/src/mbgl/renderer/painters/painter_debug.cpp
deleted file mode 100644
index 989bbab5e5..0000000000
--- a/src/mbgl/renderer/painters/painter_debug.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include <mbgl/renderer/painter.hpp>
-#include <mbgl/renderer/buckets/debug_bucket.hpp>
-#include <mbgl/renderer/render_tile.hpp>
-#include <mbgl/renderer/paint_parameters.hpp>
-#include <mbgl/map/view.hpp>
-#include <mbgl/tile/tile.hpp>
-#include <mbgl/programs/programs.hpp>
-#include <mbgl/programs/fill_program.hpp>
-#include <mbgl/util/string.hpp>
-#include <mbgl/gl/debugging.hpp>
-#include <mbgl/util/color.hpp>
-
-namespace mbgl {
-
-using namespace style;
-
-void Painter::renderTileDebug(const RenderTile& renderTile) {
-    if (frame.debugOptions == MapDebugOptions::NoDebug)
-        return;
-
-    MBGL_DEBUG_GROUP(context, std::string { "debug " } + util::toString(renderTile.id));
-
-    static const style::Properties<>::PossiblyEvaluated properties {};
-    static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
-
-    auto draw = [&] (Color color, const auto& vertexBuffer, const auto& indexBuffer, const auto& segments, auto drawMode) {
-        programs->debug.draw(
-            context,
-            drawMode,
-            gl::DepthMode::disabled(),
-            stencilModeForClipping(renderTile.clip),
-            gl::ColorMode::unblended(),
-            DebugProgram::UniformValues {
-                uniforms::u_matrix::Value{ renderTile.matrix },
-                uniforms::u_color::Value{ color }
-            },
-            vertexBuffer,
-            indexBuffer,
-            segments,
-            paintAttibuteData,
-            properties,
-            state.getZoom(),
-            "debug"
-        );
-    };
-
-    if (frame.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
-        Tile& tile = renderTile.tile;
-        if (!tile.debugBucket || tile.debugBucket->renderable != tile.isRenderable() ||
-            tile.debugBucket->complete != tile.isComplete() ||
-            !(tile.debugBucket->modified == tile.modified) ||
-            !(tile.debugBucket->expires == tile.expires) ||
-            tile.debugBucket->debugMode != frame.debugOptions) {
-            tile.debugBucket = std::make_unique<DebugBucket>(
-                tile.id, tile.isRenderable(), tile.isComplete(), tile.modified,
-                tile.expires, frame.debugOptions, context);
-        }
-
-        draw(Color::white(),
-             *tile.debugBucket->vertexBuffer,
-             *tile.debugBucket->indexBuffer,
-             tile.debugBucket->segments,
-             gl::Lines { 4.0f * frame.pixelRatio });
-
-        draw(Color::black(),
-             *tile.debugBucket->vertexBuffer,
-             *tile.debugBucket->indexBuffer,
-             tile.debugBucket->segments,
-             gl::Lines { 2.0f * frame.pixelRatio });
-    }
-
-    if (frame.debugOptions & MapDebugOptions::TileBorders) {
-        draw(Color::red(),
-             tileVertexBuffer,
-             tileBorderIndexBuffer,
-             tileBorderSegments,
-             gl::LineStrip { 4.0f * frame.pixelRatio });
-    }
-}
-
-void Painter::renderTileDebug(const mat4& matrix) {
-    if (frame.debugOptions == MapDebugOptions::NoDebug)
-        return;
-
-    static const style::Properties<>::PossiblyEvaluated properties {};
-    static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
-
-    if (frame.debugOptions & MapDebugOptions::TileBorders) {
-        programs->debug.draw(
-            context,
-            gl::LineStrip { 4.0f * frame.pixelRatio },
-            gl::DepthMode::disabled(),
-            gl::StencilMode::disabled(),
-            gl::ColorMode::unblended(),
-            DebugProgram::UniformValues {
-             uniforms::u_matrix::Value{ matrix },
-             uniforms::u_color::Value{ Color::red() }
-            },
-            tileVertexBuffer,
-            tileBorderIndexBuffer,
-            tileBorderSegments,
-            paintAttibuteData,
-            properties,
-            state.getZoom(),
-            "debug"
-        );
-    }
-}
-
-#ifndef NDEBUG
-void Painter::renderClipMasks(PaintParameters&) {
-    context.setStencilMode(gl::StencilMode::disabled());
-    context.setDepthMode(gl::DepthMode::disabled());
-    context.setColorMode(gl::ColorMode::unblended());
-    context.program = 0;
-
-#if not MBGL_USE_GLES2
-    // Reset the value in case someone else changed it, or it's dirty.
-    context.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
-
-    // Read the stencil buffer
-    const auto viewport = context.viewport.getCurrentValue();
-    auto image =
-        context.readFramebuffer<AlphaImage, gl::TextureFormat::Stencil>(viewport.size, false);
-
-    // Scale the Stencil buffer to cover the entire color space.
-    auto it = image.data.get();
-    auto end = it + viewport.size.width * viewport.size.height;
-    const auto factor = 255.0f / *std::max_element(it, end);
-    for (; it != end; ++it) {
-        *it *= factor;
-    }
-
-    context.pixelZoom = { 1, 1 };
-    context.rasterPos = { -1, -1, 0, 1 };
-    context.drawPixels(image);
-#endif // MBGL_USE_GLES2
-}
-
-void Painter::renderDepthBuffer(PaintParameters&) {
-    context.setStencilMode(gl::StencilMode::disabled());
-    context.setDepthMode(gl::DepthMode::disabled());
-    context.setColorMode(gl::ColorMode::unblended());
-    context.program = 0;
-
-#if not MBGL_USE_GLES2
-    // Scales the values in the depth buffer so that they cover the entire grayscale range. This
-    // makes it easier to spot tiny differences.
-    const float base = 1.0f / (1.0f - depthRangeSize);
-    context.pixelTransferDepth = { base, 1.0f - base };
-
-    // Read the stencil buffer
-    auto viewport = context.viewport.getCurrentValue();
-    auto image =
-        context.readFramebuffer<AlphaImage, gl::TextureFormat::Depth>(viewport.size, false);
-
-    context.pixelZoom = { 1, 1 };
-    context.rasterPos = { -1, -1, 0, 1 };
-    context.drawPixels(image);
-#endif // MBGL_USE_GLES2
-}
-#endif // NDEBUG
-
-} // namespace mbgl
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 7e7e3e6d23..e28606633a 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -1,5 +1,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/buckets/debug_bucket.hpp>
+#include <mbgl/programs/programs.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/util/math.hpp>
@@ -60,4 +62,65 @@ void RenderTile::startRender(Painter& painter) {
     matrix::multiply(nearClippedMatrix, painter.nearClippedProjMatrix, nearClippedMatrix);
 }
 
+void RenderTile::finishRender(Painter& painter) {
+    if (!used || painter.frame.debugOptions == MapDebugOptions::NoDebug)
+        return;
+
+    static const style::Properties<>::PossiblyEvaluated properties {};
+    static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
+
+    auto draw = [&] (Color color, const auto& vertexBuffer, const auto& indexBuffer, const auto& segments, auto drawMode) {
+        painter.programs->debug.draw(
+            painter.context,
+            drawMode,
+            gl::DepthMode::disabled(),
+            painter.stencilModeForClipping(clip),
+            gl::ColorMode::unblended(),
+            DebugProgram::UniformValues {
+                uniforms::u_matrix::Value{ matrix },
+                uniforms::u_color::Value{ color }
+            },
+            vertexBuffer,
+            indexBuffer,
+            segments,
+            paintAttibuteData,
+            properties,
+            painter.state.getZoom(),
+            "debug"
+        );
+    };
+
+    if (painter.frame.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
+        if (!tile.debugBucket || tile.debugBucket->renderable != tile.isRenderable() ||
+            tile.debugBucket->complete != tile.isComplete() ||
+            !(tile.debugBucket->modified == tile.modified) ||
+            !(tile.debugBucket->expires == tile.expires) ||
+            tile.debugBucket->debugMode != painter.frame.debugOptions) {
+            tile.debugBucket = std::make_unique<DebugBucket>(
+                tile.id, tile.isRenderable(), tile.isComplete(), tile.modified,
+                tile.expires, painter.frame.debugOptions, painter.context);
+        }
+
+        draw(Color::white(),
+             *tile.debugBucket->vertexBuffer,
+             *tile.debugBucket->indexBuffer,
+             tile.debugBucket->segments,
+             gl::Lines { 4.0f * painter.frame.pixelRatio });
+
+        draw(Color::black(),
+             *tile.debugBucket->vertexBuffer,
+             *tile.debugBucket->indexBuffer,
+             tile.debugBucket->segments,
+             gl::Lines { 2.0f * painter.frame.pixelRatio });
+    }
+
+    if (painter.frame.debugOptions & MapDebugOptions::TileBorders) {
+        draw(Color::red(),
+             painter.tileVertexBuffer,
+             painter.tileBorderIndexBuffer,
+             painter.tileBorderSegments,
+             gl::LineStrip { 4.0f * painter.frame.pixelRatio });
+    }
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp
index 6d374c29cb..98db111002 100644
--- a/src/mbgl/renderer/render_tile.hpp
+++ b/src/mbgl/renderer/render_tile.hpp
@@ -37,6 +37,7 @@ public:
                               const TransformState&) const;
 
     void startRender(Painter&);
+    void finishRender(Painter&);
 
     mat4 translateVtxMatrix(const mat4& tileMatrix,
                             const std::array<float, 2>& translation,
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 1cb3d9d1ba..738b8e8034 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -5,6 +5,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/programs/programs.hpp>
 #include <mbgl/util/tile_coordinate.hpp>
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/util/logging.hpp>
@@ -48,11 +49,32 @@ void RenderImageSource::startRender(Painter& painter) {
 }
 
 void RenderImageSource::finishRender(Painter& painter) {
-    if (!isLoaded()) {
+    if (!isLoaded() || !(painter.frame.debugOptions & MapDebugOptions::TileBorders)) {
         return;
     }
+
+    static const style::Properties<>::PossiblyEvaluated properties {};
+    static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
+
     for (auto matrix : matrices) {
-        painter.renderTileDebug(matrix);
+        painter.programs->debug.draw(
+            painter.context,
+            gl::LineStrip { 4.0f * painter.frame.pixelRatio },
+            gl::DepthMode::disabled(),
+            gl::StencilMode::disabled(),
+            gl::ColorMode::unblended(),
+            DebugProgram::UniformValues {
+             uniforms::u_matrix::Value{ matrix },
+             uniforms::u_color::Value{ Color::red() }
+            },
+            painter.tileVertexBuffer,
+            painter.tileBorderIndexBuffer,
+            painter.tileBorderSegments,
+            paintAttibuteData,
+            properties,
+            painter.state.getZoom(),
+            "debug"
+        );
     }
 }
 
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index 4abe189826..8d15bd59ab 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -47,9 +47,7 @@ void TilePyramid::startRender(Painter& painter) {
 
 void TilePyramid::finishRender(Painter& painter) {
     for (auto& tile : renderTiles) {
-        if (tile.used) {
-            painter.renderTileDebug(tile);
-        }
+        tile.finishRender(painter);
     }
 }