[core] Renderer for remaining layers. RenderLayer clean up.upstream/mikhail_refactor_render_layers

15 files changed, 207 insertions, 251 deletions

diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index db755adf0b..679b9f855a 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -27,6 +27,92 @@ RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::I
 
 RenderBackgroundLayer::~RenderBackgroundLayer() = default;
 
+LayerRenderer RenderBackgroundLayer::createRenderer() {
+    return [](PaintParameters& parameters, const LayerRenderItem& renderItem) {
+        // Note that for bottommost layers without a pattern, the background color is drawn with
+        // glClear rather than this method.
+        const auto& baseImpl = *renderItem.evaluatedProperties->baseImpl; 
+        const auto& evaluated = getEvaluated<BackgroundLayerProperties>(renderItem.evaluatedProperties);
+        const auto& crossfade = getCrossfade<BackgroundLayerProperties>(renderItem.evaluatedProperties);
+
+        const Properties<>::PossiblyEvaluated properties;
+        const BackgroundProgram::Binders paintAttributeData(properties, 0);
+
+        auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const UnwrappedTileID& id) {
+            const auto allUniformValues = program.computeAllUniformValues(
+                std::move(uniformValues),
+                paintAttributeData,
+                properties,
+                parameters.state.getZoom()
+            );
+            const auto allAttributeBindings = program.computeAllAttributeBindings(
+                *parameters.staticData.tileVertexBuffer,
+                paintAttributeData,
+                properties
+            );
+
+            renderItem.checkRenderability(parameters, program.activeBindingCount(allAttributeBindings));
+
+            program.draw(
+                parameters.context,
+                *parameters.renderPass,
+                gfx::Triangles(),
+                parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                gfx::StencilMode::disabled(),
+                parameters.colorModeForRenderPass(),
+                gfx::CullFaceMode::disabled(),
+                *parameters.staticData.quadTriangleIndexBuffer,
+                parameters.staticData.tileTriangleSegments,
+                allUniformValues,
+                allAttributeBindings,
+                textureBindings,
+                baseImpl.id + "/" + util::toString(id)
+            );
+        };
+
+        if (!evaluated.get<BackgroundPattern>().to.empty()) {
+            optional<ImagePosition> imagePosA = parameters.patternAtlas.getPattern(evaluated.get<BackgroundPattern>().from);
+            optional<ImagePosition> imagePosB = parameters.patternAtlas.getPattern(evaluated.get<BackgroundPattern>().to);
+
+            if (!imagePosA || !imagePosB)
+                return;
+
+            for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
+                draw(
+                    parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
+                    BackgroundPatternProgram::layoutUniformValues(
+                        parameters.matrixForTile(tileID),
+                        evaluated.get<BackgroundOpacity>(),
+                        parameters.patternAtlas.getPixelSize(),
+                        *imagePosA,
+                        *imagePosB,
+                        crossfade,
+                        tileID,
+                        parameters.state
+                    ),
+                    BackgroundPatternProgram::TextureBindings{
+                        textures::image::Value{ parameters.patternAtlas.textureBinding() },
+                    },
+                    tileID
+                );
+            }
+        } else {
+            for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
+                draw(
+                    parameters.programs.getBackgroundLayerPrograms().background,
+                    BackgroundProgram::LayoutUniformValues {
+                        uniforms::matrix::Value( parameters.matrixForTile(tileID) ),
+                        uniforms::color::Value( evaluated.get<BackgroundColor>() ),
+                        uniforms::opacity::Value( evaluated.get<BackgroundOpacity>() ),
+                    },
+                    BackgroundProgram::TextureBindings{},
+                    tileID
+                );
+            }
+        }
+    };
+}
+
 void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
     unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
@@ -50,88 +136,6 @@ bool RenderBackgroundLayer::hasCrossfade() const {
     return getCrossfade<BackgroundLayerProperties>(evaluatedProperties).t != 1;
 }
 
-void RenderBackgroundLayer::render(PaintParameters& parameters) {
-    // Note that for bottommost layers without a pattern, the background color is drawn with
-    // glClear rather than this method.
-
-    const Properties<>::PossiblyEvaluated properties;
-    const BackgroundProgram::Binders paintAttributeData(properties, 0);
-
-    auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const UnwrappedTileID& id) {
-        const auto allUniformValues = program.computeAllUniformValues(
-            std::move(uniformValues),
-            paintAttributeData,
-            properties,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = program.computeAllAttributeBindings(
-            *parameters.staticData.tileVertexBuffer,
-            paintAttributeData,
-            properties
-        );
-
-        checkRenderability(parameters, program.activeBindingCount(allAttributeBindings));
-
-        program.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::Triangles(),
-            parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-            gfx::StencilMode::disabled(),
-            parameters.colorModeForRenderPass(),
-            gfx::CullFaceMode::disabled(),
-            *parameters.staticData.quadTriangleIndexBuffer,
-            parameters.staticData.tileTriangleSegments,
-            allUniformValues,
-            allAttributeBindings,
-            textureBindings,
-            getID() + "/" + util::toString(id)
-        );
-    };
-    const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
-    const auto& crossfade = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade;
-    if (!evaluated.get<BackgroundPattern>().to.empty()) {
-        optional<ImagePosition> imagePosA = parameters.patternAtlas.getPattern(evaluated.get<BackgroundPattern>().from);
-        optional<ImagePosition> imagePosB = parameters.patternAtlas.getPattern(evaluated.get<BackgroundPattern>().to);
-
-        if (!imagePosA || !imagePosB)
-            return;
-
-        for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
-            draw(
-                parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
-                BackgroundPatternProgram::layoutUniformValues(
-                    parameters.matrixForTile(tileID),
-                    evaluated.get<BackgroundOpacity>(),
-                    parameters.patternAtlas.getPixelSize(),
-                    *imagePosA,
-                    *imagePosB,
-                    crossfade,
-                    tileID,
-                    parameters.state
-                ),
-                BackgroundPatternProgram::TextureBindings{
-                    textures::image::Value{ parameters.patternAtlas.textureBinding() },
-                },
-                tileID
-            );
-        }
-    } else {
-        for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
-            draw(
-                parameters.programs.getBackgroundLayerPrograms().background,
-                BackgroundProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( parameters.matrixForTile(tileID) ),
-                    uniforms::color::Value( evaluated.get<BackgroundColor>() ),
-                    uniforms::opacity::Value( evaluated.get<BackgroundOpacity>() ),
-                },
-                BackgroundProgram::TextureBindings{},
-                tileID
-            );
-        }
-    }
-}
-
 optional<Color> RenderBackgroundLayer::getSolidBackground() const {
     const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
     if (!evaluated.get<BackgroundPattern>().from.empty()) {
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index dfc2adf76e..352c3ac59c 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -12,12 +12,12 @@ public:
     ~RenderBackgroundLayer() override;
 
 private:
+    LayerRenderer createRenderer() override;
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     optional<Color> getSolidBackground() const override;
-    void render(PaintParameters&) override;
     void prepare(const LayerPrepareParameters&) override;
 
     // Paint properties
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index e7496df074..7b8744bd30 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -24,6 +24,77 @@ RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
       unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderCircleLayer::~RenderCircleLayer() = default;
+
+LayerRenderer RenderCircleLayer::createRenderer() {
+    return [](PaintParameters& parameters, const LayerRenderItem& renderItem) {
+        if (parameters.pass == RenderPass::Opaque) {
+            return;
+        }
+        const auto& renderTiles = renderItem.renderTiles;
+        const auto& baseImpl = *renderItem.evaluatedProperties->baseImpl; 
+
+        for (const RenderTile& tile : renderTiles) {
+            const LayerRenderData* renderData = tile.getLayerRenderData(baseImpl);
+            if (!renderData) {
+                continue;
+            }
+            auto& bucket = static_cast<CircleBucket&>(*renderData->bucket);
+            const auto& evaluated = getEvaluated<CircleLayerProperties>(renderData->layerProperties);
+            const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
+            const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
+            const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(baseImpl.id);
+
+            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 )
+                },
+                paintPropertyBinders,
+                evaluated,
+                parameters.state.getZoom()
+            );
+            const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
+                *bucket.vertexBuffer,
+                paintPropertyBinders,
+                evaluated
+            );
+
+            renderItem.checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
+
+            programInstance.draw(
+                parameters.context,
+                *parameters.renderPass,
+                gfx::Triangles(),
+                parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                gfx::StencilMode::disabled(),
+                parameters.colorModeForRenderPass(),
+                gfx::CullFaceMode::disabled(),
+                *bucket.indexBuffer,
+                bucket.segments,
+                allUniformValues,
+                allAttributeBindings,
+                CircleProgram::TextureBindings{},
+                baseImpl.id
+            );
+        }
+    };
+}
+
 void RenderCircleLayer::transition(const TransitionParameters& parameters) {
     unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
@@ -52,71 +123,6 @@ bool RenderCircleLayer::hasCrossfade() const {
     return false;
 }
 
-void RenderCircleLayer::render(PaintParameters& parameters) {
-    if (parameters.pass == RenderPass::Opaque) {
-        return;
-    }
-
-    for (const RenderTile& tile : renderTiles) {
-        const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
-        if (!renderData) {
-            continue;
-        }
-        auto& bucket = static_cast<CircleBucket&>(*renderData->bucket);
-        const auto& evaluated = getEvaluated<CircleLayerProperties>(renderData->layerProperties);
-        const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
-        const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
-        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 )
-            },
-            paintPropertyBinders,
-            evaluated,
-            parameters.state.getZoom()
-        );
-        const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
-            *bucket.vertexBuffer,
-            paintPropertyBinders,
-            evaluated
-        );
-
-        checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
-
-        programInstance.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::Triangles(),
-            parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-            gfx::StencilMode::disabled(),
-            parameters.colorModeForRenderPass(),
-            gfx::CullFaceMode::disabled(),
-            *bucket.indexBuffer,
-            bucket.segments,
-            allUniformValues,
-            allAttributeBindings,
-            CircleProgram::TextureBindings{},
-            getID()
-        );
-    }
-}
-
 GeometryCoordinate projectPoint(const GeometryCoordinate& p, const mat4& posMatrix, const Size& size) {
     vec4 pos = {{ static_cast<double>(p.x), static_cast<double>(p.y), 0, 1 }};
     matrix::transformMat4(pos, pos, posMatrix);
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index 9348e48929..eb63fe0ed5 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -9,14 +9,14 @@ namespace mbgl {
 class RenderCircleLayer final : public RenderLayer {
 public:
     explicit RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
-    ~RenderCircleLayer() final = default;
+    ~RenderCircleLayer() override;
 
 private:
+    LayerRenderer createRenderer() override;
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void render(PaintParameters&) override;
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index 75c21997b0..aaa3867fe5 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -34,6 +34,51 @@ RenderCustomLayer::~RenderCustomLayer() {
     }
 }
 
+LayerRenderer RenderCustomLayer::createRenderer() {
+    if (host != impl(baseImpl).host) {
+        //If the context changed, deinitialize the previous one before initializing the new one.
+        if (host && !contextDestroyed) {
+            MBGL_CHECK_ERROR(host->deinitialize());
+        }
+        host = impl(baseImpl).host;
+        MBGL_CHECK_ERROR(host->initialize());
+    }
+
+    return [host = this->host](PaintParameters& paintParameters, const LayerRenderItem&) {
+        // TODO: remove cast
+        auto& glContext = static_cast<gl::Context&>(paintParameters.context);
+        const TransformState& state = paintParameters.state;
+
+        // Reset GL state to a known state so the CustomLayer always has a clean slate.
+        glContext.bindVertexArray = 0;
+        glContext.setDepthMode(paintParameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly));
+        glContext.setStencilMode(gfx::StencilMode::disabled());
+        glContext.setColorMode(paintParameters.colorModeForRenderPass());
+        glContext.setCullFaceMode(gfx::CullFaceMode::disabled());
+
+        CustomLayerRenderParameters parameters;
+
+        parameters.width = state.getSize().width;
+        parameters.height = state.getSize().height;
+        parameters.latitude = state.getLatLng().latitude();
+        parameters.longitude = state.getLatLng().longitude();
+        parameters.zoom = state.getZoom();
+        parameters.bearing = -state.getBearing() * util::RAD2DEG;
+        parameters.pitch = state.getPitch();
+        parameters.fieldOfView = state.getFieldOfView();
+        mat4 projMatrix;
+        state.getProjMatrix(projMatrix);
+        parameters.projectionMatrix = projMatrix;
+
+        MBGL_CHECK_ERROR(host->render(parameters));
+
+        // Reset the view back to our original one, just in case the CustomLayer changed
+        // the viewport or Framebuffer.
+        paintParameters.backend.getDefaultRenderable().getResource<gl::RenderableResource>().bind();
+        glContext.setDirtyState();
+    };
+}
+
 void RenderCustomLayer::evaluate(const PropertyEvaluationParameters&) {
     passes = RenderPass::Translucent;
     // It is fine to not update `evaluatedProperties`, as `baseImpl` should never be updated for this layer.
@@ -53,47 +98,4 @@ void RenderCustomLayer::markContextDestroyed() {
 void RenderCustomLayer::prepare(const LayerPrepareParameters&) {
 }
 
-void RenderCustomLayer::render(PaintParameters& paintParameters) {
-    if (host != impl(baseImpl).host) {
-        //If the context changed, deinitialize the previous one before initializing the new one.
-        if (host && !contextDestroyed) {
-            MBGL_CHECK_ERROR(host->deinitialize());
-        }
-        host = impl(baseImpl).host;
-        MBGL_CHECK_ERROR(host->initialize());
-    }
-
-    // TODO: remove cast
-    auto& glContext = static_cast<gl::Context&>(paintParameters.context);
-    const TransformState& state = paintParameters.state;
-
-    // Reset GL state to a known state so the CustomLayer always has a clean slate.
-    glContext.bindVertexArray = 0;
-    glContext.setDepthMode(paintParameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly));
-    glContext.setStencilMode(gfx::StencilMode::disabled());
-    glContext.setColorMode(paintParameters.colorModeForRenderPass());
-    glContext.setCullFaceMode(gfx::CullFaceMode::disabled());
-
-    CustomLayerRenderParameters parameters;
-
-    parameters.width = state.getSize().width;
-    parameters.height = state.getSize().height;
-    parameters.latitude = state.getLatLng().latitude();
-    parameters.longitude = state.getLatLng().longitude();
-    parameters.zoom = state.getZoom();
-    parameters.bearing = -state.getBearing() * util::RAD2DEG;
-    parameters.pitch = state.getPitch();
-    parameters.fieldOfView = state.getFieldOfView();
-    mat4 projMatrix;
-    state.getProjMatrix(projMatrix);
-    parameters.projectionMatrix = projMatrix;
-
-    MBGL_CHECK_ERROR(host->render(parameters));
-
-    // Reset the view back to our original one, just in case the CustomLayer changed
-    // the viewport or Framebuffer.
-    paintParameters.backend.getDefaultRenderable().getResource<gl::RenderableResource>().bind();
-    glContext.setDirtyState();
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index 698621eae6..04dc3cefa4 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -11,6 +11,7 @@ public:
     ~RenderCustomLayer() override;
 
 private:
+    LayerRenderer createRenderer() override;
     void transition(const TransitionParameters&) override {}
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -18,8 +19,6 @@ private:
     void markContextDestroyed() override;
     void prepare(const LayerPrepareParameters&) override;
 
-    void render(PaintParameters&) override;
-
     bool contextDestroyed = false;
     std::shared_ptr<style::CustomLayerHost> host;
 };
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index 3410814444..77dcd3976a 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -17,7 +17,6 @@ private:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void render(PaintParameters&) override {}
 
     bool queryIntersectsFeature(
         const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index dda4bdd372..cb0e64f57f 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -20,7 +20,6 @@ private:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void render(PaintParameters&) override {}
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index 229a0eabbd..48e4bd27f9 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -24,7 +24,6 @@ private:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void render(PaintParameters&) override {}
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 068c7b14ca..0bffdfc44b 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -19,7 +19,6 @@ private:
     bool hasTransition() const override;
     bool hasCrossfade() const override;
 
-    void render(PaintParameters&) override {}
     void prepare(const LayerPrepareParameters&) override;
 
     // Paint properties
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 930e83ddc1..3570c10522 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -24,7 +24,6 @@ private:
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     void prepare(const LayerPrepareParameters&) override;
-    void render(PaintParameters&) override {}
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 6f2c52b654..8802e7ad0a 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -20,7 +20,6 @@ private:
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     void prepare(const LayerPrepareParameters&) override;
-    void render(PaintParameters&) override {}
 
     // Paint properties
     style::RasterPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 3951587016..5f17fb3b4a 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -66,7 +66,6 @@ private:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void render(PaintParameters&) override {}
     void prepare(const LayerPrepareParameters&) override;
 
     // Paint properties
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index 3813e9f6b6..bb9e1533ab 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -58,10 +58,6 @@ void LayerRenderItem::checkRenderability(const PaintParameters& parameters,
     }
 }
 
-LayerRenderer RenderLayer::createRenderer() {
-    return [this](PaintParameters& pass, const LayerRenderItem&){ render(pass); };
-}
-
 LayerUploader RenderLayer::createUploader() {
     return {};
 }
@@ -85,10 +81,6 @@ const std::string& RenderLayer::getID() const {
     return baseImpl->id;
 }
 
-bool RenderLayer::hasRenderPass(RenderPass pass) const {
-    return bool(passes & pass);
-}
-
 bool RenderLayer::needsRendering() const {
     return passes != RenderPass::None
            && baseImpl->visibility != style::VisibilityType::None;
@@ -124,32 +116,5 @@ void RenderLayer::markContextDestroyed() {
     // no-op
 }
 
-void RenderLayer::checkRenderability(const PaintParameters& parameters,
-                                     const uint32_t activeBindingCount) {
-    // Only warn once for every layer.
-    if (hasRenderFailures) {
-        return;
-    }
-
-    if (activeBindingCount > parameters.context.maximumVertexBindingCount) {
-        Log::Info(Event::OpenGL,
-                "The layer '%s' uses more data-driven properties than the current device "
-                "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);
-        hasRenderFailures = true;
-    } else if (activeBindingCount > parameters.context.minimumRequiredVertexBindingCount) {
-        Log::Info(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);
-        hasRenderFailures = true;
-    }
-}
-
 } //namespace mbgl
 
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index dbc3572e86..a27654df16 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -105,17 +105,12 @@ public:
 
     const std::string& getID() const;
 
-    // Checks whether this layer needs to be rendered in the given render pass.
-    bool hasRenderPass(RenderPass) const;
-
     // Checks whether this layer can be rendered.
     bool needsRendering() const;
 
     // Checks whether the given zoom is inside this layer zoom range.
     bool supportsZoom(float zoom) const;
 
-    virtual void render(PaintParameters&) = 0;
-
     // Check wether the given geometry intersects
     // with the feature
     virtual bool queryIntersectsFeature(
@@ -143,13 +138,9 @@ public:
     virtual optional<Color> getSolidBackground() const;
 
 protected:
-    virtual LayerRenderer createRenderer();
+    virtual LayerRenderer createRenderer() = 0;
     virtual LayerUploader createUploader();
-    // Checks whether the current hardware can render this layer. If it can't, we'll show a warning
-    // in the console to inform the developer.
-    void checkRenderability(const PaintParameters&, uint32_t activeBindingCount);
 
-protected:
     // Stores current set of tiles to be rendered for this layer.
     RenderTiles renderTiles;
 
@@ -161,10 +152,6 @@ protected:
 
 private:
     RenderTiles filterRenderTiles(RenderTiles) const;
-    // Some layers may not render correctly on some hardware when the vertex attribute limit of
-    // that GPU is exceeded. More attributes are used when adding many data driven paint properties
-    // to a layer.
-    bool hasRenderFailures = false;
 };
 
 } // namespace mbgl