From b481469394a7c55ec43aeaec5a19622a2fae7df5 Mon Sep 17 00:00:00 2001 From: Mikhail Pozdnyakov Date: Mon, 8 Jul 2019 11:45:19 +0300 Subject: [core] Renderer for RenderHillshadeLayer and RenderRasterLayer --- .../renderer/layers/render_hillshade_layer.cpp | 312 +++++++++++---------- .../renderer/layers/render_hillshade_layer.hpp | 6 +- src/mbgl/renderer/layers/render_raster_layer.cpp | 277 +++++++++--------- src/mbgl/renderer/layers/render_raster_layer.hpp | 3 +- 4 files changed, 306 insertions(+), 292 deletions(-) diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp index 2cbb77f24b..49fc5eedc5 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp @@ -29,194 +29,202 @@ RenderHillshadeLayer::RenderHillshadeLayer(Immutable RenderHillshadeLayer::getLatRange(const UnwrappedTileID& id) { +namespace { +std::array 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 {{ (float)latlng0.latitude(), (float)latlng1.latitude() }}; } -const std::array RenderHillshadeLayer::getLight(const PaintParameters& parameters) { - const auto& evaluated = static_cast(*evaluatedProperties).evaluated; +std::array getLight(const PaintParameters& parameters, const HillshadePaintProperties::PossiblyEvaluated& evaluated) { float azimuthal = evaluated.get() * util::DEG2RAD; - if (evaluated.get() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getBearing(); + if (evaluated.get() == HillshadeIlluminationAnchorType::Viewport) { + azimuthal = azimuthal - parameters.state.getBearing(); + } return {{evaluated.get(), azimuthal}}; } +} // namespace -void RenderHillshadeLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); -} +LayerRenderer RenderHillshadeLayer::createRenderer() { + return [maxzoom = this->maxzoom](PaintParameters& parameters, const LayerRenderItem& renderItem) { + if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D) return; -void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) { - auto properties = makeMutable( - staticImmutableCast(baseImpl), - unevaluated.evaluate(parameters)); - passes = (properties->evaluated.get() > 0) - ? (RenderPass::Translucent | RenderPass::Pass3D) - : RenderPass::None; + const auto& renderTiles = renderItem.renderTiles; + const auto& evaluated = getEvaluated(renderItem.evaluatedProperties); + const auto& baseImpl = *renderItem.evaluatedProperties->baseImpl; - evaluatedProperties = std::move(properties); -} + auto draw = [&] (const mat4& matrix, + const auto& vertexBuffer, + const auto& indexBuffer, + const auto& segments, + const UnwrappedTileID& id, + const auto& textureBindings) { + auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshade; -bool RenderHillshadeLayer::hasTransition() const { - return unevaluated.hasTransition(); -} - -bool RenderHillshadeLayer::hasCrossfade() const { - return false; -} - -void RenderHillshadeLayer::prepare(const LayerPrepareParameters& params) { - RenderLayer::prepare(params); - maxzoom = params.source->getMaxZoom(); -} - -void RenderHillshadeLayer::render(PaintParameters& parameters) { - if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D) - return; - const auto& evaluated = static_cast(*evaluatedProperties).evaluated; - auto draw = [&] (const mat4& matrix, - const auto& vertexBuffer, - const auto& indexBuffer, - const auto& segments, - const UnwrappedTileID& id, - const auto& textureBindings) { - auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshade; - - const HillshadeProgram::Binders paintAttributeData{ evaluated, 0 }; - - const auto allUniformValues = programInstance.computeAllUniformValues( - HillshadeProgram::LayoutUniformValues { - uniforms::matrix::Value( matrix ), - uniforms::highlight::Value( evaluated.get() ), - uniforms::shadow::Value( evaluated.get() ), - uniforms::accent::Value( evaluated.get() ), - uniforms::light::Value( getLight(parameters) ), - uniforms::latrange::Value( getLatRange(id) ), - }, - paintAttributeData, - evaluated, - parameters.state.getZoom() - ); - const auto allAttributeBindings = programInstance.computeAllAttributeBindings( - vertexBuffer, - paintAttributeData, - 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(), - indexBuffer, - segments, - allUniformValues, - allAttributeBindings, - textureBindings, - getID() + "/" + util::toString(id) - ); - }; - - mat4 mat; - matrix::ortho(mat, 0, util::EXTENT, -util::EXTENT, 0, 0, 1); - matrix::translate(mat, mat, 0, -util::EXTENT, 0); - - for (const RenderTile& tile : renderTiles) { - auto* bucket_ = tile.getBucket(*baseImpl); - if (!bucket_) { - continue; - } - auto& bucket = static_cast(*bucket_); - - if (!bucket.hasData()){ - continue; - } - - if (!bucket.isPrepared() && parameters.pass == RenderPass::Pass3D) { - assert(bucket.dem); - const uint16_t stride = bucket.getDEMData().stride; - const uint16_t tilesize = bucket.getDEMData().dim; - auto view = parameters.context.createOffscreenTexture({ tilesize, tilesize }); - - auto renderPass = parameters.encoder->createRenderPass( - "hillshade prepare", { *view, Color{ 0.0f, 0.0f, 0.0f, 0.0f }, {}, {} }); - - const Properties<>::PossiblyEvaluated properties; - const HillshadePrepareProgram::Binders paintAttributeData{ properties, 0 }; - - auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshadePrepare; + const HillshadeProgram::Binders paintAttributeData{ evaluated, 0 }; 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) ), + HillshadeProgram::LayoutUniformValues { + uniforms::matrix::Value( matrix ), + uniforms::highlight::Value( evaluated.get() ), + uniforms::shadow::Value( evaluated.get() ), + uniforms::accent::Value( evaluated.get() ), + uniforms::light::Value( getLight(parameters, evaluated) ), + uniforms::latrange::Value( getLatRange(id) ), }, paintAttributeData, - properties, + evaluated, parameters.state.getZoom() ); const auto allAttributeBindings = programInstance.computeAllAttributeBindings( - *parameters.staticData.rasterVertexBuffer, + vertexBuffer, paintAttributeData, - properties + evaluated ); - checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); + renderItem.checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); programInstance.draw( parameters.context, - *renderPass, + *parameters.renderPass, gfx::Triangles(), parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.rasterSegments, + indexBuffer, + segments, allUniformValues, allAttributeBindings, - HillshadePrepareProgram::TextureBindings{ - textures::image::Value{ bucket.dem->getResource() }, - }, - getID() + "/p/" + util::toString(tile.id) + textureBindings, + baseImpl.id + "/" + util::toString(id) ); - bucket.texture = std::move(view->getTexture()); - bucket.setPrepared(true); - } else if (parameters.pass == RenderPass::Translucent) { - assert(bucket.texture); - - if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) { - // Draw only the parts of the tile that aren't drawn by another tile in the layer. - draw(parameters.matrixForTile(tile.id, true), - *bucket.vertexBuffer, - *bucket.indexBuffer, - bucket.segments, - tile.id, - HillshadeProgram::TextureBindings{ - textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear }, - }); - } else { - // Draw the full tile. - draw(parameters.matrixForTile(tile.id, true), - *parameters.staticData.rasterVertexBuffer, - *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.rasterSegments, - tile.id, - HillshadeProgram::TextureBindings{ - textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear }, - }); + }; + + mat4 mat; + matrix::ortho(mat, 0, util::EXTENT, -util::EXTENT, 0, 0, 1); + matrix::translate(mat, mat, 0, -util::EXTENT, 0); + + for (const RenderTile& tile : renderTiles) { + auto* bucket_ = tile.getBucket(baseImpl); + if (!bucket_) { + continue; + } + auto& bucket = static_cast(*bucket_); + + if (!bucket.hasData()) { + continue; + } + + if (!bucket.isPrepared() && parameters.pass == RenderPass::Pass3D) { + assert(bucket.dem); + const uint16_t stride = bucket.getDEMData().stride; + const uint16_t tilesize = bucket.getDEMData().dim; + auto view = parameters.context.createOffscreenTexture({ tilesize, tilesize }); + + auto renderPass = parameters.encoder->createRenderPass( + "hillshade prepare", { *view, Color{ 0.0f, 0.0f, 0.0f, 0.0f }, {}, {} }); + + const Properties<>::PossiblyEvaluated properties; + const HillshadePrepareProgram::Binders paintAttributeData{ properties, 0 }; + + 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) ), + }, + paintAttributeData, + properties, + parameters.state.getZoom() + ); + const auto allAttributeBindings = programInstance.computeAllAttributeBindings( + *parameters.staticData.rasterVertexBuffer, + paintAttributeData, + properties + ); + + renderItem.checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); + + programInstance.draw( + parameters.context, + *renderPass, + gfx::Triangles(), + parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), + gfx::StencilMode::disabled(), + parameters.colorModeForRenderPass(), + gfx::CullFaceMode::disabled(), + *parameters.staticData.quadTriangleIndexBuffer, + parameters.staticData.rasterSegments, + allUniformValues, + allAttributeBindings, + HillshadePrepareProgram::TextureBindings{ + textures::image::Value{ bucket.dem->getResource() }, + }, + baseImpl.id + "/p/" + util::toString(tile.id) + ); + bucket.texture = std::move(view->getTexture()); + bucket.setPrepared(true); + } else if (parameters.pass == RenderPass::Translucent) { + assert(bucket.texture); + + if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) { + // Draw only the parts of the tile that aren't drawn by another tile in the layer. + draw(parameters.matrixForTile(tile.id, true), + *bucket.vertexBuffer, + *bucket.indexBuffer, + bucket.segments, + tile.id, + HillshadeProgram::TextureBindings{ + textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear }, + }); + } else { + // Draw the full tile. + draw(parameters.matrixForTile(tile.id, true), + *parameters.staticData.rasterVertexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, + parameters.staticData.rasterSegments, + tile.id, + HillshadeProgram::TextureBindings{ + textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear }, + }); + } } + + } - + }; +} - } +void RenderHillshadeLayer::transition(const TransitionParameters& parameters) { + unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); +} + +void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) { + auto properties = makeMutable( + staticImmutableCast(baseImpl), + unevaluated.evaluate(parameters)); + passes = (properties->evaluated.get() > 0) + ? (RenderPass::Translucent | RenderPass::Pass3D) + : RenderPass::None; + + evaluatedProperties = std::move(properties); +} + +bool RenderHillshadeLayer::hasTransition() const { + return unevaluated.hasTransition(); +} + +bool RenderHillshadeLayer::hasCrossfade() const { + return false; +} + +void RenderHillshadeLayer::prepare(const LayerPrepareParameters& params) { + RenderLayer::prepare(params); + maxzoom = params.source->getMaxZoom(); } } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp index 61f5c507a9..068c7b14ca 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp @@ -13,20 +13,18 @@ public: ~RenderHillshadeLayer() 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; + 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 getLatRange(const UnwrappedTileID& id); - const std::array 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 e22e14275c..b5bcfd11df 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.cpp +++ b/src/mbgl/renderer/layers/render_raster_layer.cpp @@ -25,27 +25,8 @@ RenderRasterLayer::RenderRasterLayer(Immutable _impl) RenderRasterLayer::~RenderRasterLayer() = default; -void RenderRasterLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); -} - -void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) { - auto properties = makeMutable( - staticImmutableCast(baseImpl), - unevaluated.evaluate(parameters)); - passes = properties->evaluated.get() > 0 ? RenderPass::Translucent : RenderPass::None; - evaluatedProperties = std::move(properties); -} - -bool RenderRasterLayer::hasTransition() const { - return unevaluated.hasTransition(); -} - -bool RenderRasterLayer::hasCrossfade() const { - return false; -} - -static float saturationFactor(float saturation) { +namespace { +float saturationFactor(float saturation) { if (saturation > 0) { return 1 - 1 / (1.001 - saturation); } else { @@ -53,7 +34,7 @@ static float saturationFactor(float saturation) { } } -static float contrastFactor(float contrast) { +float contrastFactor(float contrast) { if (contrast > 0) { return 1 / (1 - contrast); } else { @@ -61,7 +42,7 @@ static float contrastFactor(float contrast) { } } -static std::array spinWeights(float spin) { +std::array spinWeights(float spin) { spin *= util::DEG2RAD; float s = std::sin(spin); float c = std::cos(spin); @@ -72,124 +53,150 @@ static std::array spinWeights(float spin) { }}; return spin_weights; } +} // namespace + +LayerRenderer RenderRasterLayer::createRenderer() { + return [imageData = this->imageData](PaintParameters& parameters, const LayerRenderItem& renderItem) { + if (parameters.pass != RenderPass::Translucent) return; + + const auto& renderTiles = renderItem.renderTiles; + const auto& evaluated = getEvaluated(renderItem.evaluatedProperties); + const auto& baseImpl = *renderItem.evaluatedProperties->baseImpl; + + RasterProgram::Binders paintAttributeData{ evaluated, 0 }; + + auto draw = [&] (const mat4& matrix, + const auto& vertexBuffer, + const auto& indexBuffer, + const auto& segments, + const auto& textureBindings, + 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() ), + uniforms::fade_t::Value( 1 ), + uniforms::brightness_low::Value( evaluated.get() ), + uniforms::brightness_high::Value( evaluated.get() ), + uniforms::saturation_factor::Value( saturationFactor(evaluated.get()) ), + uniforms::contrast_factor::Value( contrastFactor(evaluated.get()) ), + uniforms::spin_weights::Value( spinWeights(evaluated.get()) ), + uniforms::buffer_scale::Value( 1.0f ), + uniforms::scale_parent::Value( 1.0f ), + uniforms::tl_parent::Value( std::array {{ 0.0f, 0.0f }} ), + }, + paintAttributeData, + evaluated, + parameters.state.getZoom() + ); + const auto allAttributeBindings = programInstance.computeAllAttributeBindings( + vertexBuffer, + paintAttributeData, + 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(), + indexBuffer, + segments, + allUniformValues, + allAttributeBindings, + textureBindings, + baseImpl.id + "/" + drawScopeID + ); + }; + + const gfx::TextureFilterType filter = evaluated.get() == RasterResamplingType::Nearest ? gfx::TextureFilterType::Nearest : gfx::TextureFilterType::Linear; + + if (imageData && !imageData->bucket->needsUpload()) { + RasterBucket& bucket = *imageData->bucket; + assert(bucket.texture); -void RenderRasterLayer::prepare(const LayerPrepareParameters& params) { - RenderLayer::prepare(params); - imageData = params.source->getImageRenderData(); + size_t i = 0; + 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 + std::to_string(i++)); + } + } else { + for (const RenderTile& tile : renderTiles) { + auto* bucket_ = tile.getBucket(baseImpl); + if (!bucket_) { + continue; + } + auto& bucket = static_cast(*bucket_); + + if (!bucket.hasData()) + continue; + + assert(bucket.texture); + if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) { + // Draw only the parts of the tile that aren't drawn by another tile in the layer. + draw(parameters.matrixForTile(tile.id, true), + *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 { + // Draw the full tile. + draw(parameters.matrixForTile(tile.id, true), + *parameters.staticData.rasterVertexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, + parameters.staticData.rasterSegments, + RasterProgram::TextureBindings{ + textures::image0::Value{ bucket.texture->getResource(), filter }, + textures::image1::Value{ bucket.texture->getResource(), filter }, + }, + bucket.drawScopeID); + } + } + } + }; } -void RenderRasterLayer::render(PaintParameters& parameters) { - if (parameters.pass != RenderPass::Translucent) - return; - const auto& evaluated = static_cast(*evaluatedProperties).evaluated; - RasterProgram::Binders paintAttributeData{ evaluated, 0 }; - - auto draw = [&] (const mat4& matrix, - const auto& vertexBuffer, - const auto& indexBuffer, - const auto& segments, - const auto& textureBindings, - 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() ), - uniforms::fade_t::Value( 1 ), - uniforms::brightness_low::Value( evaluated.get() ), - uniforms::brightness_high::Value( evaluated.get() ), - uniforms::saturation_factor::Value( saturationFactor(evaluated.get()) ), - uniforms::contrast_factor::Value( contrastFactor(evaluated.get()) ), - uniforms::spin_weights::Value( spinWeights(evaluated.get()) ), - uniforms::buffer_scale::Value( 1.0f ), - uniforms::scale_parent::Value( 1.0f ), - uniforms::tl_parent::Value( std::array {{ 0.0f, 0.0f }} ), - }, - paintAttributeData, - evaluated, - parameters.state.getZoom() - ); - const auto allAttributeBindings = programInstance.computeAllAttributeBindings( - vertexBuffer, - paintAttributeData, - 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(), - indexBuffer, - segments, - allUniformValues, - allAttributeBindings, - textureBindings, - getID() + "/" + drawScopeID - ); - }; +void RenderRasterLayer::transition(const TransitionParameters& parameters) { + unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); +} - const gfx::TextureFilterType filter = evaluated.get() == RasterResamplingType::Nearest ? gfx::TextureFilterType::Nearest : gfx::TextureFilterType::Linear; - - if (imageData && !imageData->bucket->needsUpload()) { - RasterBucket& bucket = *imageData->bucket; - assert(bucket.texture); - - size_t i = 0; - 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 + std::to_string(i++)); - } - } else { - for (const RenderTile& tile : renderTiles) { - auto* bucket_ = tile.getBucket(*baseImpl); - if (!bucket_) { - continue; - } - auto& bucket = static_cast(*bucket_); +void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) { + auto properties = makeMutable( + staticImmutableCast(baseImpl), + unevaluated.evaluate(parameters)); + passes = properties->evaluated.get() > 0 ? RenderPass::Translucent : RenderPass::None; + evaluatedProperties = std::move(properties); +} - if (!bucket.hasData()) - continue; +bool RenderRasterLayer::hasTransition() const { + return unevaluated.hasTransition(); +} - assert(bucket.texture); - if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) { - // Draw only the parts of the tile that aren't drawn by another tile in the layer. - draw(parameters.matrixForTile(tile.id, true), - *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 { - // Draw the full tile. - draw(parameters.matrixForTile(tile.id, true), - *parameters.staticData.rasterVertexBuffer, - *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.rasterSegments, - RasterProgram::TextureBindings{ - textures::image0::Value{ bucket.texture->getResource(), filter }, - textures::image1::Value{ bucket.texture->getResource(), filter }, - }, - bucket.drawScopeID); - } - } - } +bool RenderRasterLayer::hasCrossfade() const { + return false; +} + +void RenderRasterLayer::prepare(const LayerPrepareParameters& params) { + RenderLayer::prepare(params); + imageData = params.source->getImageRenderData(); } } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp index 94bbd36a0d..6f2c52b654 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.hpp +++ b/src/mbgl/renderer/layers/render_raster_layer.hpp @@ -14,12 +14,13 @@ public: ~RenderRasterLayer() override; private: + LayerRenderer createRenderer() override; void transition(const TransitionParameters&) override; void evaluate(const PropertyEvaluationParameters&) override; bool hasTransition() const override; bool hasCrossfade() const override; void prepare(const LayerPrepareParameters&) override; - void render(PaintParameters&) override; + void render(PaintParameters&) override {} // Paint properties style::RasterPaintProperties::Unevaluated unevaluated; -- cgit v1.2.1