[core] Fix readability-* errors

As reported by clang-tidy-8.

16 files changed, 172 insertions, 202 deletions

diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 7ddcedef9f..86aa91160c 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -60,10 +60,15 @@ private:
     };
 
     class Distances;
-    void addCurrentVertex(const GeometryCoordinate& currentVertex, double& distance,
-            const Point<double>& normal, double endLeft, double endRight, bool round,
-            std::size_t startVertex, std::vector<LineBucket::TriangleElement>& triangleStore,
-            optional<Distances> distances);
+    void addCurrentVertex(const GeometryCoordinate& currentCoordinate,
+                          double& distance,
+                          const Point<double>& normal,
+                          double endLeft,
+                          double endRight,
+                          bool round,
+                          std::size_t startVertex,
+                          std::vector<LineBucket::TriangleElement>& triangleStore,
+                          optional<Distances> distances);
 
     void addPieSliceVertex(const GeometryCoordinate& currentVertex, double distance,
             const Point<double>& extrude, bool lineTurnsLeft, std::size_t startVertex,
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index 00ba14589a..5577eac2d9 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -72,7 +72,7 @@ public:
                  float zoom,
                  bool iconsNeedLinear,
                  bool sortFeaturesByY,
-                 std::string bucketLeaderID,
+                 std::string bucketName_,
                  const std::vector<SymbolInstance>&&,
                  const std::vector<SortKeyRange>&&,
                  const float tilePixelRatio,
diff --git a/src/mbgl/renderer/image_atlas.cpp b/src/mbgl/renderer/image_atlas.cpp
index 71a0010972..36da19bbce 100644
--- a/src/mbgl/renderer/image_atlas.cpp
+++ b/src/mbgl/renderer/image_atlas.cpp
@@ -33,10 +33,10 @@ const mapbox::Bin& _packImage(mapbox::ShelfPack& pack, const style::Image::Impl&
                                 bin.y + padding
                              },
                              image.image.size);
-    uint32_t x = bin.x + padding,
-            y = bin.y + padding,
-            w = image.image.size.width,
-            h = image.image.size.height;
+    uint32_t x = bin.x + padding;
+    uint32_t y = bin.y + padding;
+    uint32_t w = image.image.size.width;
+    uint32_t h = image.image.size.height;
 
     if (imageType == ImageType::Pattern) {
             // Add 1 pixel wrapped padding on each side of the image.
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index fc916e1d1b..3e12b74db9 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -100,7 +100,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
     };
 
     if (segments.empty()) {
-        segments = parameters.staticData.tileTriangleSegments();
+        segments = RenderStaticData::tileTriangleSegments();
     }
 
     const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index e5d7e6230e..a8a70d2a3a 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -75,35 +75,26 @@ void RenderCircleLayer::render(PaintParameters& parameters) {
         const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
         auto& programInstance = parameters.programs.getCircleLayerPrograms().circle;
-   
-        const auto allUniformValues = programInstance.computeAllUniformValues(
-            CircleProgram::LayoutUniformValues {
-                uniforms::matrix::Value(
-                    tile.translatedMatrix(evaluated.get<CircleTranslate>(),
-                                          evaluated.get<CircleTranslateAnchor>(),
-                                          parameters.state)
-                ),
-                uniforms::scale_with_map::Value( scaleWithMap ),
-                uniforms::extrude_scale::Value( pitchWithMap
-                    ? std::array<float, 2> {{
-                        tile.id.pixelsToTileUnits(1, parameters.state.getZoom()),
-                        tile.id.pixelsToTileUnits(1, parameters.state.getZoom()) }}
-                    : parameters.pixelsToGLUnits ),
-                uniforms::device_pixel_ratio::Value( parameters.pixelRatio ),
-                uniforms::camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() ),
-                uniforms::pitch_with_map::Value( pitchWithMap )
-            },
+
+        const auto allUniformValues = CircleProgram::computeAllUniformValues(
+            CircleProgram::LayoutUniformValues{
+                uniforms::matrix::Value(tile.translatedMatrix(
+                    evaluated.get<CircleTranslate>(), evaluated.get<CircleTranslateAnchor>(), parameters.state)),
+                uniforms::scale_with_map::Value(scaleWithMap),
+                uniforms::extrude_scale::Value(
+                    pitchWithMap ? std::array<float, 2>{{tile.id.pixelsToTileUnits(1, parameters.state.getZoom()),
+                                                         tile.id.pixelsToTileUnits(1, parameters.state.getZoom())}}
+                                 : parameters.pixelsToGLUnits),
+                uniforms::device_pixel_ratio::Value(parameters.pixelRatio),
+                uniforms::camera_to_center_distance::Value(parameters.state.getCameraToCenterDistance()),
+                uniforms::pitch_with_map::Value(pitchWithMap)},
             paintPropertyBinders,
             evaluated,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-            *bucket.vertexBuffer,
-            paintPropertyBinders,
-            evaluated
-        );
+            parameters.state.getZoom());
+        const auto allAttributeBindings =
+            CircleProgram::computeAllAttributeBindings(*bucket.vertexBuffer, paintPropertyBinders, evaluated);
 
-        checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+        checkRenderability(parameters, CircleProgram::activeBindingCount(allAttributeBindings));
 
         programInstance.draw(
             parameters.context,
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 03a7d12fc4..cc1ebdc175 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -112,23 +112,18 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
 
             auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap;
 
-            const auto allUniformValues = programInstance.computeAllUniformValues(
-                HeatmapProgram::LayoutUniformValues {
-                    uniforms::intensity::Value( evaluated.get<style::HeatmapIntensity>() ),
-                    uniforms::matrix::Value( tile.matrix ),
-                    uniforms::heatmap::extrude_scale::Value( extrudeScale )
-                },
+            const auto allUniformValues = HeatmapProgram::computeAllUniformValues(
+                HeatmapProgram::LayoutUniformValues{
+                    uniforms::intensity::Value(evaluated.get<style::HeatmapIntensity>()),
+                    uniforms::matrix::Value(tile.matrix),
+                    uniforms::heatmap::extrude_scale::Value(extrudeScale)},
                 paintPropertyBinders,
                 evaluated,
-                parameters.state.getZoom()
-            );
-            const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-                *bucket.vertexBuffer,
-                paintPropertyBinders,
-                evaluated
-            );
+                parameters.state.getZoom());
+            const auto allAttributeBindings =
+                HeatmapProgram::computeAllAttributeBindings(*bucket.vertexBuffer, paintPropertyBinders, evaluated);
 
-            checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+            checkRenderability(parameters, HeatmapProgram::activeBindingCount(allAttributeBindings));
 
             programInstance.draw(parameters.context,
                                  *renderPass,
@@ -156,27 +151,23 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
 
         auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmapTexture;
 
-        const auto allUniformValues = programInstance.computeAllUniformValues(
+        const auto allUniformValues = HeatmapTextureProgram::computeAllUniformValues(
             HeatmapTextureProgram::LayoutUniformValues{
-                uniforms::matrix::Value( viewportMat ),
-                uniforms::world::Value( size ),
-                uniforms::opacity::Value( getEvaluated<HeatmapLayerProperties>(evaluatedProperties).get<HeatmapOpacity>() )
-            },
+                uniforms::matrix::Value(viewportMat),
+                uniforms::world::Value(size),
+                uniforms::opacity::Value(
+                    getEvaluated<HeatmapLayerProperties>(evaluatedProperties).get<HeatmapOpacity>())},
             paintAttributeData,
             properties,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-            *parameters.staticData.heatmapTextureVertexBuffer,
-            paintAttributeData,
-            properties
-        );
+            parameters.state.getZoom());
+        const auto allAttributeBindings = HeatmapTextureProgram::computeAllAttributeBindings(
+            *parameters.staticData.heatmapTextureVertexBuffer, paintAttributeData, properties);
 
-        checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+        checkRenderability(parameters, HeatmapTextureProgram::activeBindingCount(allAttributeBindings));
 
         if (segments.empty()) {
             // Copy over the segments so that we can create our own DrawScopes.
-            segments = parameters.staticData.heatmapTextureSegments();
+            segments = RenderStaticData::heatmapTextureSegments();
         }
         programInstance.draw(
             parameters.context,
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 5c4d4f1d95..a937c857cc 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -33,13 +33,13 @@ RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl
 
 RenderHillshadeLayer::~RenderHillshadeLayer() = default;
 
-const std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTileID& id) {
-   const LatLng latlng0 = LatLng(id);
-   const LatLng latlng1 = LatLng(UnwrappedTileID(id.canonical.z, id.canonical.x, id.canonical.y + 1));
-   return {{static_cast<float>(latlng0.latitude()), static_cast<float>(latlng1.latitude())}};
+std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTileID& id) {
+    const LatLng latlng0 = LatLng(id);
+    const LatLng latlng1 = LatLng(UnwrappedTileID(id.canonical.z, id.canonical.x, id.canonical.y + 1));
+    return {{static_cast<float>(latlng0.latitude()), static_cast<float>(latlng1.latitude())}};
 }
 
-const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters) {
+std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters) {
     const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
     float azimuthal = evaluated.get<HillshadeIlluminationDirection>() * util::DEG2RAD;
     if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getBearing();
@@ -89,26 +89,22 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
 
         const HillshadeProgram::Binders paintAttributeData{ evaluated, 0 };
 
-        const auto allUniformValues = programInstance.computeAllUniformValues(
-            HillshadeProgram::LayoutUniformValues {
-                uniforms::matrix::Value( matrix ),
-                uniforms::highlight::Value( evaluated.get<HillshadeHighlightColor>() ),
-                uniforms::shadow::Value( evaluated.get<HillshadeShadowColor>() ),
-                uniforms::accent::Value( evaluated.get<HillshadeAccentColor>() ),
-                uniforms::light::Value( getLight(parameters) ),
-                uniforms::latrange::Value( getLatRange(id) ),
+        const auto allUniformValues = HillshadeProgram::computeAllUniformValues(
+            HillshadeProgram::LayoutUniformValues{
+                uniforms::matrix::Value(matrix),
+                uniforms::highlight::Value(evaluated.get<HillshadeHighlightColor>()),
+                uniforms::shadow::Value(evaluated.get<HillshadeShadowColor>()),
+                uniforms::accent::Value(evaluated.get<HillshadeAccentColor>()),
+                uniforms::light::Value(getLight(parameters)),
+                uniforms::latrange::Value(getLatRange(id)),
             },
             paintAttributeData,
             evaluated,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-            vertexBuffer,
-            paintAttributeData,
-            evaluated
-        );
+            parameters.state.getZoom());
+        const auto allAttributeBindings =
+            HillshadeProgram::computeAllAttributeBindings(vertexBuffer, paintAttributeData, evaluated);
 
-        checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+        checkRenderability(parameters, HillshadeProgram::activeBindingCount(allAttributeBindings));
 
         programInstance.draw(parameters.context,
                              *parameters.renderPass,
@@ -154,29 +150,25 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
             
             auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshadePrepare;
 
-            const auto allUniformValues = programInstance.computeAllUniformValues(
-                HillshadePrepareProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( mat ),
-                    uniforms::dimension::Value( {{stride, stride}} ),
-                    uniforms::zoom::Value( float(tile.id.canonical.z) ),
-                    uniforms::maxzoom::Value( float(maxzoom) ),
-                    uniforms::unpack::Value( bucket.getDEMData().getUnpackVector() ),
+            const auto allUniformValues = HillshadePrepareProgram::computeAllUniformValues(
+                HillshadePrepareProgram::LayoutUniformValues{
+                    uniforms::matrix::Value(mat),
+                    uniforms::dimension::Value({{stride, stride}}),
+                    uniforms::zoom::Value(float(tile.id.canonical.z)),
+                    uniforms::maxzoom::Value(float(maxzoom)),
+                    uniforms::unpack::Value(bucket.getDEMData().getUnpackVector()),
                 },
                 paintAttributeData,
                 properties,
-                parameters.state.getZoom()
-            );
-            const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-                *parameters.staticData.rasterVertexBuffer,
-                paintAttributeData,
-                properties
-            );
+                parameters.state.getZoom());
+            const auto allAttributeBindings = HillshadePrepareProgram::computeAllAttributeBindings(
+                *parameters.staticData.rasterVertexBuffer, paintAttributeData, properties);
 
-            checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+            checkRenderability(parameters, HillshadePrepareProgram::activeBindingCount(allAttributeBindings));
 
             // Copy over the segments so that we can create our own DrawScopes that get destroyed
             // after this draw call.
-            auto segments = parameters.staticData.rasterSegments();
+            auto segments = RenderStaticData::rasterSegments();
             programInstance.draw(parameters.context,
                                  *renderPass,
                                  gfx::Triangles(),
@@ -211,7 +203,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
                 // Draw the full tile.
                 if (bucket.segments.empty()) {
                     // Copy over the segments so that we can create our own DrawScopes.
-                    bucket.segments = parameters.staticData.rasterSegments();
+                    bucket.segments = RenderStaticData::rasterSegments();
                 }
                 draw(parameters.matrixForTile(tile.id, true),
                      *parameters.staticData.rasterVertexBuffer,
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 61f5c507a9..829b669712 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -25,8 +25,8 @@ private:
     style::HillshadePaintProperties::Unevaluated unevaluated;
     uint8_t maxzoom = util::TERRAIN_RGB_MAXZOOM;
 
-    const std::array<float, 2> getLatRange(const UnwrappedTileID& id);
-    const std::array<float, 2> getLight(const PaintParameters& parameters);
+    std::array<float, 2> getLatRange(const UnwrappedTileID& id);
+    std::array<float, 2> getLight(const PaintParameters& parameters);
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 047333d5e5..345222e7ba 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -100,31 +100,27 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
                      const std::string& drawScopeID) {
         auto& programInstance = parameters.programs.getRasterLayerPrograms().raster;
 
-        const auto allUniformValues = programInstance.computeAllUniformValues(
-            RasterProgram::LayoutUniformValues {
-                uniforms::matrix::Value( matrix ),
-                uniforms::opacity::Value( evaluated.get<RasterOpacity>() ),
-                uniforms::fade_t::Value( 1 ),
-                uniforms::brightness_low::Value( evaluated.get<RasterBrightnessMin>() ),
-                uniforms::brightness_high::Value( evaluated.get<RasterBrightnessMax>() ),
-                uniforms::saturation_factor::Value( saturationFactor(evaluated.get<RasterSaturation>()) ),
-                uniforms::contrast_factor::Value( contrastFactor(evaluated.get<RasterContrast>()) ),
-                uniforms::spin_weights::Value( spinWeights(evaluated.get<RasterHueRotate>()) ),
-                uniforms::buffer_scale::Value( 1.0f ),
-                uniforms::scale_parent::Value( 1.0f ),
-                uniforms::tl_parent::Value( std::array<float, 2> {{ 0.0f, 0.0f }} ),
+        const auto allUniformValues = RasterProgram::computeAllUniformValues(
+            RasterProgram::LayoutUniformValues{
+                uniforms::matrix::Value(matrix),
+                uniforms::opacity::Value(evaluated.get<RasterOpacity>()),
+                uniforms::fade_t::Value(1),
+                uniforms::brightness_low::Value(evaluated.get<RasterBrightnessMin>()),
+                uniforms::brightness_high::Value(evaluated.get<RasterBrightnessMax>()),
+                uniforms::saturation_factor::Value(saturationFactor(evaluated.get<RasterSaturation>())),
+                uniforms::contrast_factor::Value(contrastFactor(evaluated.get<RasterContrast>())),
+                uniforms::spin_weights::Value(spinWeights(evaluated.get<RasterHueRotate>())),
+                uniforms::buffer_scale::Value(1.0f),
+                uniforms::scale_parent::Value(1.0f),
+                uniforms::tl_parent::Value(std::array<float, 2>{{0.0f, 0.0f}}),
             },
             paintAttributeData,
             evaluated,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-            vertexBuffer,
-            paintAttributeData,
-            evaluated
-        );
+            parameters.state.getZoom());
+        const auto allAttributeBindings =
+            RasterProgram::computeAllAttributeBindings(vertexBuffer, paintAttributeData, evaluated);
 
-        checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+        checkRenderability(parameters, RasterProgram::activeBindingCount(allAttributeBindings));
 
         programInstance.draw(
             parameters.context,
@@ -188,7 +184,7 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
                 // Draw the full tile.
                 if (bucket.segments.empty()) {
                     // Copy over the segments so that we can create our own DrawScopes.
-                    bucket.segments = parameters.staticData.rasterSegments();
+                    bucket.segments = RenderStaticData::rasterSegments();
                 }
                 draw(parameters.matrixForTile(tile.id, true),
                      *parameters.staticData.rasterVertexBuffer,
diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp
index b2f958b14e..3b7f12f776 100644
--- a/src/mbgl/renderer/paint_parameters.cpp
+++ b/src/mbgl/renderer/paint_parameters.cpp
@@ -143,14 +143,15 @@ void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) {
                      gfx::CullFaceMode::disabled(),
                      *staticData.quadTriangleIndexBuffer,
                      staticData.clippingMaskSegments,
-                     program.computeAllUniformValues(
+                     ClippingMaskProgram::computeAllUniformValues(
                          ClippingMaskProgram::LayoutUniformValues{
                              uniforms::matrix::Value(matrixForTile(renderTile.id)),
                          },
                          paintAttributeData,
                          properties,
                          state.getZoom()),
-                     program.computeAllAttributeBindings(*staticData.tileVertexBuffer, paintAttributeData, properties),
+                     ClippingMaskProgram::computeAllAttributeBindings(
+                         *staticData.tileVertexBuffer, paintAttributeData, properties),
                      ClippingMaskProgram::TextureBindings{},
                      "clipping/" + util::toString(stencilID));
     }
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index fe1b151b58..3d3f760254 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -73,16 +73,16 @@ void RenderLayer::checkRenderability(const PaintParameters& parameters,
                    "supports, and will have rendering errors. To ensure compatibility with this "
                    "device, use %d fewer data driven properties in this layer.",
                    getID().c_str(),
-                   activeBindingCount - parameters.context.minimumRequiredVertexBindingCount);
+                   activeBindingCount - gfx::Context::minimumRequiredVertexBindingCount);
         hasRenderFailures = true;
-    } else if (activeBindingCount > parameters.context.minimumRequiredVertexBindingCount) {
+    } else if (activeBindingCount > gfx::Context::minimumRequiredVertexBindingCount) {
         Log::Warning(Event::OpenGL,
-                   "The layer '%s' uses more data-driven properties than some devices may support. "
-                   "Though it will render correctly on this device, it may have rendering errors "
-                   "on other devices. To ensure compatibility with all devices, use %d fewer "
-                   "data-driven properties in this layer.",
-                   getID().c_str(),
-                   activeBindingCount - parameters.context.minimumRequiredVertexBindingCount);
+                     "The layer '%s' uses more data-driven properties than some devices may support. "
+                     "Though it will render correctly on this device, it may have rendering errors "
+                     "on other devices. To ensure compatibility with all devices, use %d fewer "
+                     "data-driven properties in this layer.",
+                     getID().c_str(),
+                     activeBindingCount - gfx::Context::minimumRequiredVertexBindingCount);
         hasRenderFailures = true;
     }
 }
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index 921b764e2d..d199101b52 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -681,11 +681,7 @@ bool RenderOrchestrator::isLoaded() const {
         }
     }
 
-    if (!imageManager->isLoaded()) {
-        return false;
-    }
-
-    return true;
+    return imageManager->isLoaded();
 }
 
 void RenderOrchestrator::clearData() {
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 71e5895402..773eef731e 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -138,57 +138,54 @@ void RenderTile::finishRender(PaintParameters& parameters) const {
 
     if (parameters.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
         assert(debugBucket);
-        const auto allAttributeBindings = program.computeAllAttributeBindings(
-            *debugBucket->vertexBuffer,
-            paintAttributeData,
-            properties
-        );
-
-        program.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::Lines{4.0f * parameters.pixelRatio},
-            gfx::DepthMode::disabled(),
-            gfx::StencilMode::disabled(),
-            gfx::ColorMode::unblended(),
-            gfx::CullFaceMode::disabled(),
-            *debugBucket->indexBuffer,
-            debugBucket->segments,
-            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
-                                                                              uniforms::color::Value(Color::white()),
-                                                                              uniforms::overlay_scale::Value(1.0f)},
-                                            paintAttributeData,
-                                            properties,
-                                            parameters.state.getZoom()),
-            allAttributeBindings,
-            DebugProgram::TextureBindings{textures::image::Value{debugBucket->texture->getResource()}},
-            "text-outline");
-
-        program.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::Lines{2.0f * parameters.pixelRatio},
-            gfx::DepthMode::disabled(),
-            gfx::StencilMode::disabled(),
-            gfx::ColorMode::unblended(),
-            gfx::CullFaceMode::disabled(),
-            *debugBucket->indexBuffer,
-            debugBucket->segments,
-            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
-                                                                              uniforms::color::Value(Color::black()),
-                                                                              uniforms::overlay_scale::Value(1.0f)},
-                                            paintAttributeData,
-                                            properties,
-                                            parameters.state.getZoom()),
-            allAttributeBindings,
-            DebugProgram::TextureBindings{textures::image::Value{debugBucket->texture->getResource()}},
-            "text");
+        const auto allAttributeBindings =
+            DebugProgram::computeAllAttributeBindings(*debugBucket->vertexBuffer, paintAttributeData, properties);
+
+        program.draw(parameters.context,
+                     *parameters.renderPass,
+                     gfx::Lines{4.0f * parameters.pixelRatio},
+                     gfx::DepthMode::disabled(),
+                     gfx::StencilMode::disabled(),
+                     gfx::ColorMode::unblended(),
+                     gfx::CullFaceMode::disabled(),
+                     *debugBucket->indexBuffer,
+                     debugBucket->segments,
+                     DebugProgram::computeAllUniformValues(
+                         DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                           uniforms::color::Value(Color::white()),
+                                                           uniforms::overlay_scale::Value(1.0f)},
+                         paintAttributeData,
+                         properties,
+                         parameters.state.getZoom()),
+                     allAttributeBindings,
+                     DebugProgram::TextureBindings{textures::image::Value{debugBucket->texture->getResource()}},
+                     "text-outline");
+
+        program.draw(parameters.context,
+                     *parameters.renderPass,
+                     gfx::Lines{2.0f * parameters.pixelRatio},
+                     gfx::DepthMode::disabled(),
+                     gfx::StencilMode::disabled(),
+                     gfx::ColorMode::unblended(),
+                     gfx::CullFaceMode::disabled(),
+                     *debugBucket->indexBuffer,
+                     debugBucket->segments,
+                     DebugProgram::computeAllUniformValues(
+                         DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                           uniforms::color::Value(Color::black()),
+                                                           uniforms::overlay_scale::Value(1.0f)},
+                         paintAttributeData,
+                         properties,
+                         parameters.state.getZoom()),
+                     allAttributeBindings,
+                     DebugProgram::TextureBindings{textures::image::Value{debugBucket->texture->getResource()}},
+                     "text");
     }
 
     if (parameters.debugOptions & MapDebugOptions::TileBorders) {
         assert(debugBucket);
         if (debugBucket->tileBorderSegments.empty()) {
-            debugBucket->tileBorderSegments = parameters.staticData.tileBorderSegments();
+            debugBucket->tileBorderSegments = RenderStaticData::tileBorderSegments();
         }
         parameters.programs.debug.draw(
             parameters.context,
@@ -200,13 +197,14 @@ void RenderTile::finishRender(PaintParameters& parameters) const {
             gfx::CullFaceMode::disabled(),
             *parameters.staticData.tileBorderIndexBuffer,
             debugBucket->tileBorderSegments,
-            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
-                                                                              uniforms::color::Value(Color::red()),
-                                                                              uniforms::overlay_scale::Value(1.0f)},
-                                            paintAttributeData,
-                                            properties,
-                                            parameters.state.getZoom()),
-            program.computeAllAttributeBindings(
+            DebugProgram::computeAllUniformValues(
+                DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                  uniforms::color::Value(Color::red()),
+                                                  uniforms::overlay_scale::Value(1.0f)},
+                paintAttributeData,
+                properties,
+                parameters.state.getZoom()),
+            DebugProgram::computeAllAttributeBindings(
                 *parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
             DebugProgram::TextureBindings{textures::image::Value{debugBucket->texture->getResource()}},
             "border");
diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp
index 836cb6c6cc..448d449984 100644
--- a/src/mbgl/renderer/render_tile.hpp
+++ b/src/mbgl/renderer/render_tile.hpp
@@ -41,11 +41,11 @@ public:
     // Contains the tile ID string for painting debug information.
     std::unique_ptr<DebugBucket> debugBucket;
 
-    mat4 translatedMatrix(const std::array<float, 2>& translate,
+    mat4 translatedMatrix(const std::array<float, 2>& translation,
                           style::TranslateAnchorType anchor,
                           const TransformState&) const;
 
-    mat4 translatedClipMatrix(const std::array<float, 2>& translate,
+    mat4 translatedClipMatrix(const std::array<float, 2>& translation,
                               style::TranslateAnchorType anchor,
                               const TransformState&) const;
 
diff --git a/src/mbgl/renderer/renderer_state.cpp b/src/mbgl/renderer/renderer_state.cpp
index 4cbe9de9c5..9a70efeee4 100644
--- a/src/mbgl/renderer/renderer_state.cpp
+++ b/src/mbgl/renderer/renderer_state.cpp
@@ -13,7 +13,7 @@ CameraOptions RendererState::getCameraOptions(const UpdateParameters& updatePara
 
 bool RendererState::hasImage(const UpdateParameters& updateParameters, const std::string& id) {
     for (const auto& image : *updateParameters.images) {
-        if (image.get()->id == id) {
+        if (image->id == id) {
             return true;
         }
     }
@@ -22,7 +22,7 @@ bool RendererState::hasImage(const UpdateParameters& updateParameters, const std
 
 bool RendererState::hasLayer(const UpdateParameters& updateParameters, const std::string& id) {
     for (const auto& layer : *updateParameters.layers) {
-        if (layer.get()->id == id) {
+        if (layer->id == id) {
             return true;
         }
     }
@@ -31,7 +31,7 @@ bool RendererState::hasLayer(const UpdateParameters& updateParameters, const std
 
 bool RendererState::hasSource(const UpdateParameters& updateParameters, const std::string& id) {
     for (const auto& source : *updateParameters.sources) {
-        if (source.get()->id == id) {
+        if (source->id == id) {
             return true;
         }
     }
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 215bbb1c92..64bbf10580 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -50,15 +50,15 @@ void ImageSourceRenderData::render(PaintParameters& parameters) const {
                              gfx::ColorMode::unblended(),
                              gfx::CullFaceMode::disabled(),
                              *parameters.staticData.tileBorderIndexBuffer,
-                             parameters.staticData.tileBorderSegments(),
-                             programInstance.computeAllUniformValues(
+                             RenderStaticData::tileBorderSegments(),
+                             DebugProgram::computeAllUniformValues(
                                  DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
                                                                    uniforms::color::Value(Color::red()),
                                                                    uniforms::overlay_scale::Value(1.0f)},
                                  paintAttributeData,
                                  properties,
                                  parameters.state.getZoom()),
-                             programInstance.computeAllAttributeBindings(
+                             DebugProgram::computeAllAttributeBindings(
                                  *parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
                              DebugProgram::TextureBindings{textures::image::Value{debugTexture->getResource()}},
                              "image");