[core] RenderLayer::render(PaintParameters, RenderSource*) -> render(PaintParameters)

2019-05-19 18:20:31 +03:00
parent 25093370e2
commit e79080771b
26 changed files with 91 additions and 71 deletions
--- a/include/mbgl/util/constants.hpp
+++ b/include/mbgl/util/constants.hpp
@@ -61,6 +61,8 @@ constexpr int DEFAULT_RATE_LIMIT_TIMEOUT = 5;

 constexpr const char* API_BASE_URL = "https://api.mapbox.com";

+constexpr uint8_t TERRAIN_RGB_MAXZOOM = 15;
+
 } // namespace util

 namespace debug {
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -61,7 +61,7 @@ void RenderBackgroundLayer::upload(gfx::UploadPass&, UploadParameters& parameter
    }
 }

-void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderBackgroundLayer::render(PaintParameters& parameters) {
    // Note that for bottommost layers without a pattern, the background color is drawn with
    // glClear rather than this method.

--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -18,7 +18,7 @@ private:
    bool hasCrossfade() const override;
    optional<Color> getSolidBackground() const override;
    void upload(gfx::UploadPass&, UploadParameters&) override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    // Paint properties
    style::BackgroundPaintProperties::Unevaluated unevaluated;
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -52,7 +52,7 @@ bool RenderCircleLayer::hasCrossfade() const {
    return false;
 }

-void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderCircleLayer::render(PaintParameters& parameters) {
    if (parameters.pass == RenderPass::Opaque) {
        return;
    }
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -16,7 +16,7 @@ private:
    void evaluate(const PropertyEvaluationParameters&) override;
    bool hasTransition() const override;
    bool hasCrossfade() const override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool queryIntersectsFeature(
            const GeometryCoordinates&,
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -50,7 +50,7 @@ void RenderCustomLayer::markContextDestroyed() {
    contextDestroyed = true;
 }

-void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*) {
+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) {
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -17,7 +17,7 @@ private:
    bool hasCrossfade() const override;
    void markContextDestroyed() override;

-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool contextDestroyed = false;
    std::shared_ptr<style::CustomLayerHost> host;
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -55,7 +55,7 @@ bool RenderFillExtrusionLayer::hasCrossfade() const {
    return getCrossfade<FillExtrusionLayerProperties>(evaluatedProperties).t != 1;
 }

-void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
    if (parameters.pass != RenderPass::Translucent) {
        return;
    }
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -17,7 +17,7 @@ private:
    void evaluate(const PropertyEvaluationParameters&) override;
    bool hasTransition() const override;
    bool hasCrossfade() const override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool queryIntersectsFeature(
        const GeometryCoordinates&,
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -72,7 +72,7 @@ bool RenderFillLayer::hasCrossfade() const {
    return getCrossfade<FillLayerProperties>(evaluatedProperties).t != 1;
 }

-void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderFillLayer::render(PaintParameters& parameters) {
    if (unevaluated.get<FillPattern>().isUndefined()) {
        parameters.renderTileClippingMasks(renderTiles);
        for (const RenderTile& tile : renderTiles) {
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -19,7 +19,7 @@ private:
    void evaluate(const PropertyEvaluationParameters&) override;
    bool hasTransition() const override;
    bool hasCrossfade() const override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool queryIntersectsFeature(
            const GeometryCoordinates&,
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -62,7 +62,7 @@ void RenderHeatmapLayer::upload(gfx::UploadPass& uploadPass, UploadParameters&)
    }
 }

-void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderHeatmapLayer::render(PaintParameters& parameters) {
    if (parameters.pass == RenderPass::Opaque) {
        return;
    }
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -20,7 +20,7 @@ private:
    bool hasTransition() const override;
    bool hasCrossfade() const override;
    void upload(gfx::UploadPass&, UploadParameters&) override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool queryIntersectsFeature(
            const GeometryCoordinates&,
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -65,14 +65,17 @@ bool RenderHillshadeLayer::hasCrossfade() const {
    return false;
 }

-void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src) {
+void RenderHillshadeLayer::prepare(const LayerPrepareParameters& params) {
+    RenderLayer::prepare(params);
+    if (auto* demsrc = params.source->as<RenderRasterDEMSource>()) {
+        maxzoom = demsrc->getMaxZoom();
+    }
+}
+
+void RenderHillshadeLayer::render(PaintParameters& parameters) {
    if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
        return;
-    const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
-    auto* demsrc = static_cast<RenderRasterDEMSource*>(src);
-    const uint8_t TERRAIN_RGB_MAXZOOM = 15;
-    const uint8_t maxzoom = demsrc != nullptr ? demsrc->getMaxZoom() : TERRAIN_RGB_MAXZOOM;
-
+    const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;  
    auto draw = [&] (const mat4& matrix,
                     const auto& vertexBuffer,
                     const auto& indexBuffer,
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -18,10 +18,12 @@ private:
    bool hasTransition() const override;
    bool hasCrossfade() const override;

-    void render(PaintParameters&, RenderSource* src) override;
+    void render(PaintParameters&) override;
+    void prepare(const LayerPrepareParameters&) override;

    // Paint properties
    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);
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -91,7 +91,7 @@ void RenderLineLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& uplo
    }
 }

-void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderLineLayer::render(PaintParameters& parameters) {
    if (parameters.pass == RenderPass::Opaque) {
        return;
    }
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -21,7 +21,7 @@ private:
    bool hasTransition() const override;
    bool hasCrossfade() const override;
    void upload(gfx::UploadPass&, UploadParameters&) override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;

    bool queryIntersectsFeature(
            const GeometryCoordinates&,
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -2,7 +2,6 @@
 #include <mbgl/renderer/buckets/raster_bucket.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
-#include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/programs/raster_program.hpp>
@@ -73,7 +72,18 @@ static std::array<float, 3> spinWeights(float spin) {
    return spin_weights;
 }

-void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source) {
+void RenderRasterLayer::prepare(const LayerPrepareParameters& params) {
+    RenderLayer::prepare(params);
+    auto* imageSource = params.source->as<RenderImageSource>();
+    if (imageSource && imageSource->isLoaded()) {
+        assert(imageSource->isEnabled());
+        assert(imageSource->sharedData.bucket);
+        assert(imageSource->sharedData.matrices);
+        imageData = imageSource->sharedData;
+    }
+}
+
+void RenderRasterLayer::render(PaintParameters& parameters) {
    if (parameters.pass != RenderPass::Translucent)
        return;
    const auto& evaluated = static_cast<const RasterLayerProperties&>(*evaluatedProperties).evaluated;
@@ -132,22 +142,20 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source

    const gfx::TextureFilterType filter = evaluated.get<RasterResampling>() == RasterResamplingType::Nearest ? gfx::TextureFilterType::Nearest : gfx::TextureFilterType::Linear;

-    if (auto* imageSource = source->as<RenderImageSource>()) {
-        if (imageSource->isEnabled() && imageSource->isLoaded() && !imageSource->bucket->needsUpload()) {
-            RasterBucket& bucket = *imageSource->bucket;
-            assert(bucket.texture);
+    if (imageData && !imageData->bucket->needsUpload()) {
+        RasterBucket& bucket = *imageData->bucket;
+        assert(bucket.texture);

-            for (auto matrix_ : imageSource->matrices) {
-                draw(matrix_,
-                     *bucket.vertexBuffer,
-                     *bucket.indexBuffer,
-                     bucket.segments,
-                     RasterProgram::TextureBindings{
-                         textures::image0::Value{ bucket.texture->getResource(), filter },
-                         textures::image1::Value{ bucket.texture->getResource(), filter },
-                     },
-                     bucket.drawScopeID);
-            }
+        for (const auto& matrix_ : *imageData->matrices) {
+            draw(matrix_,
+                *bucket.vertexBuffer,
+                *bucket.indexBuffer,
+                bucket.segments,
+                RasterProgram::TextureBindings{
+                    textures::image0::Value{ bucket.texture->getResource(), filter },
+                    textures::image1::Value{ bucket.texture->getResource(), filter },
+                },
+                bucket.drawScopeID);
        }
    } else {
        for (const RenderTile& tile : renderTiles) {
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -1,6 +1,7 @@
 #pragma once

 #include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 #include <mbgl/style/layers/raster_layer_properties.hpp>

@@ -16,11 +17,12 @@ private:
    void evaluate(const PropertyEvaluationParameters&) override;
    bool hasTransition() const override;
    bool hasCrossfade() const override;
-
-    void render(PaintParameters&, RenderSource*) override;
+    void prepare(const LayerPrepareParameters&) override;
+    void render(PaintParameters&) override;

    // Paint properties
    style::RasterPaintProperties::Unevaluated unevaluated;
+    optional<ImageLayerRenderData> imageData;
 };

 } // namespace mbgl
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -431,7 +431,7 @@ void RenderSymbolLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& up
    }
 }

-void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
+void RenderSymbolLayer::render(PaintParameters& parameters) {
    if (parameters.pass == RenderPass::Opaque) {
        return;
    }
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -66,7 +66,7 @@ private:
    bool hasTransition() const override;
    bool hasCrossfade() const override;
    void upload(gfx::UploadPass&, UploadParameters&) override;
-    void render(PaintParameters&, RenderSource*) override;
+    void render(PaintParameters&) override;
    void prepare(const LayerPrepareParameters&) override;

    // Paint properties
--- a/src/mbgl/renderer/paint_parameters.cpp
+++ b/src/mbgl/renderer/paint_parameters.cpp
@@ -30,7 +30,7 @@ PaintParameters::PaintParameters(gfx::Context& context_,
                    gfx::RendererBackend& backend_,
                    const UpdateParameters& updateParameters,
                    const EvaluatedLight& evaluatedLight_,
-		    const TransformParameters& transformParams_,
+                    const TransformParameters& transformParams_,
                    RenderStaticData& staticData_,
                    ImageManager& imageManager_,
                    LineAtlas& lineAtlas_)
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -78,7 +78,7 @@ public:
    bool supportsZoom(float zoom) const;

    virtual void upload(gfx::UploadPass&, UploadParameters&) {}
-    virtual void render(PaintParameters&, RenderSource*) = 0;
+    virtual void render(PaintParameters&) = 0;

    // Check wether the given geometry intersects
    // with the feature
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -424,7 +424,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
            RenderLayer& renderLayer = it->layer;
            if (renderLayer.hasRenderPass(parameters.pass)) {
                const auto layerDebugGroup(parameters.encoder->createDebugGroup(renderLayer.getID().c_str()));
-                renderLayer.render(parameters, it->source);
+                renderLayer.render(parameters);
            }
        }
    }
@@ -458,7 +458,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
            RenderLayer& renderLayer = it->layer;
            if (renderLayer.hasRenderPass(parameters.pass)) {
                const auto layerDebugGroup(parameters.renderPass->createDebugGroup(renderLayer.getID().c_str()));
-                renderLayer.render(parameters, it->source);
+                renderLayer.render(parameters);
            }
        }
    }
@@ -475,7 +475,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
            RenderLayer& renderLayer = it->layer;
            if (renderLayer.hasRenderPass(parameters.pass)) {
                const auto layerDebugGroup(parameters.renderPass->createDebugGroup(renderLayer.getID().c_str()));
-                renderLayer.render(parameters, it->source);
+                renderLayer.render(parameters);
            }
        }
    }
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -28,12 +28,12 @@ const style::ImageSource::Impl& RenderImageSource::impl() const {
 }

 bool RenderImageSource::isLoaded() const {
-    return !!bucket;
+    return !!sharedData.bucket;
 }

 void RenderImageSource::upload(gfx::UploadPass& uploadPass) {
-    if (bucket->needsUpload()) {
-        bucket->upload(uploadPass);
+    if (sharedData.bucket->needsUpload()) {
+        sharedData.bucket->upload(uploadPass);
    }
 }

@@ -42,14 +42,13 @@ void RenderImageSource::prepare(const SourcePrepareParameters& parameters) {
        return;
    }

-    matrices.clear();
+    sharedData.matrices = std::make_shared<std::vector<mat4>>(tileIds.size(), mat4());
    const auto& transformParams = parameters.transform;
-    for (auto& tileId : tileIds) {
-        mat4 matrix;
+    for (size_t i = 0u; i < tileIds.size(); ++i) {
+        mat4& matrix = (*sharedData.matrices)[i];
        matrix::identity(matrix);
-        transformParams.state.matrixFor(matrix, tileId);
+        transformParams.state.matrixFor(matrix, tileIds[i]);
        matrix::multiply(matrix, transformParams.alignedProjMatrix, matrix);
-        matrices.push_back(matrix);
    }
 }

@@ -63,7 +62,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {

    auto& programInstance = parameters.programs.debug;

-    for (auto matrix : matrices) {
+    for (auto matrix : *sharedData.matrices) {
        programInstance.draw(
            parameters.context,
            *parameters.renderPass,
@@ -194,29 +193,29 @@ void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
        auto gc = TileCoordinate::toGeometryCoordinate(tileIds[0], tileCoords);
        geomCoords.push_back(gc);
    }
-    if (!bucket) {
-        bucket = std::make_unique<RasterBucket>(image);
+    if (!sharedData.bucket) {
+        sharedData.bucket = std::make_unique<RasterBucket>(image);
    } else {
-        bucket->clear();
-        if (image != bucket->image) {
-            bucket->setImage(image);
+        sharedData.bucket->clear();
+        if (image != sharedData.bucket->image) {
+            sharedData.bucket->setImage(image);
        }
    }

    // Set Bucket Vertices, Indices, and segments
-    bucket->vertices.emplace_back(
+    sharedData.bucket->vertices.emplace_back(
        RasterProgram::layoutVertex({ geomCoords[0].x, geomCoords[0].y }, { 0, 0 }));
-    bucket->vertices.emplace_back(
+    sharedData.bucket->vertices.emplace_back(
        RasterProgram::layoutVertex({ geomCoords[1].x, geomCoords[1].y }, { util::EXTENT, 0 }));
-    bucket->vertices.emplace_back(
+    sharedData.bucket->vertices.emplace_back(
        RasterProgram::layoutVertex({ geomCoords[3].x, geomCoords[3].y }, { 0, util::EXTENT }));
-    bucket->vertices.emplace_back(
+    sharedData.bucket->vertices.emplace_back(
        RasterProgram::layoutVertex({ geomCoords[2].x, geomCoords[2].y }, { util::EXTENT, util::EXTENT }));

-    bucket->indices.emplace_back(0, 1, 2);
-    bucket->indices.emplace_back(1, 2, 3);
+    sharedData.bucket->indices.emplace_back(0, 1, 2);
+    sharedData.bucket->indices.emplace_back(1, 2, 3);

-    bucket->segments.emplace_back(0, 0, 4, 6);
+    sharedData.bucket->segments.emplace_back(0, 0, 4, 6);
 }

 void RenderImageSource::dumpDebugLogs() const {
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -8,6 +8,12 @@ namespace mbgl {

 class RasterBucket;

+class ImageLayerRenderData {
+public:
+    std::shared_ptr<RasterBucket> bucket;
+    std::shared_ptr<std::vector<mat4>> matrices;
+};
+
 class RenderImageSource : public RenderSource {
 public:
    RenderImageSource(Immutable<style::ImageSource::Impl>);
@@ -44,12 +50,10 @@ public:

 private:
    friend class RenderRasterLayer;
-
    const style::ImageSource::Impl& impl() const;

+    ImageLayerRenderData sharedData;
    std::vector<UnwrappedTileID> tileIds;
-    std::unique_ptr<RasterBucket> bucket;
-    std::vector<mat4> matrices;
 };

 template <>