diff options
Diffstat (limited to 'src/mbgl/renderer')
20 files changed, 250 insertions, 262 deletions
diff --git a/src/mbgl/renderer/buckets/debug_bucket.cpp b/src/mbgl/renderer/buckets/debug_bucket.cpp index 13380c0905..fcdc727f4b 100644 --- a/src/mbgl/renderer/buckets/debug_bucket.cpp +++ b/src/mbgl/renderer/buckets/debug_bucket.cpp @@ -2,7 +2,6 @@ #include <mbgl/geometry/debug_font_data.hpp> #include <mbgl/tile/tile_id.hpp> #include <mbgl/util/string.hpp> -#include <mbgl/util/id.hpp> #include <cmath> #include <string> @@ -20,9 +19,7 @@ DebugBucket::DebugBucket(const OverscaledTileID& id, complete(complete_), modified(std::move(modified_)), expires(std::move(expires_)), - debugMode(debugMode_), - drawScopeID("__debug/" + util::toHex(util::nextID())) { - + debugMode(debugMode_) { auto addText = [&] (const std::string& text, double left, double baseline, double scale) { for (uint8_t c : text) { if (c < 32 || c >= 127) diff --git a/src/mbgl/renderer/buckets/debug_bucket.hpp b/src/mbgl/renderer/buckets/debug_bucket.hpp index 2b735b4987..78b1cbb8ff 100644 --- a/src/mbgl/renderer/buckets/debug_bucket.hpp +++ b/src/mbgl/renderer/buckets/debug_bucket.hpp @@ -40,9 +40,9 @@ public: gfx::IndexVector<gfx::Lines> indices; SegmentVector<DebugAttributes> segments; + SegmentVector<DebugAttributes> tileBorderSegments; optional<gfx::VertexBuffer<DebugLayoutVertex>> vertexBuffer; optional<gfx::IndexBuffer> indexBuffer; - const std::string drawScopeID; }; } // namespace mbgl diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp index a26b9a5065..859ee8d2a2 100644 --- a/src/mbgl/renderer/buckets/raster_bucket.cpp +++ b/src/mbgl/renderer/buckets/raster_bucket.cpp @@ -2,21 +2,15 @@ #include <mbgl/renderer/layers/render_raster_layer.hpp> #include <mbgl/programs/raster_program.hpp> #include <mbgl/gfx/upload_pass.hpp> -#include <mbgl/util/id.hpp> namespace mbgl { using namespace style; RasterBucket::RasterBucket(PremultipliedImage&& image_) - : image(std::make_shared<PremultipliedImage>(std::move(image_))), - drawScopeID(util::toHex(util::nextID())) { -} + : image(std::make_shared<PremultipliedImage>(std::move(image_))) {} -RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_) - : image(std::move(image_)), - drawScopeID(util::toHex(util::nextID())) { -} +RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_) : image(std::move(image_)) {} RasterBucket::~RasterBucket() = default; @@ -27,8 +21,10 @@ void RasterBucket::upload(gfx::UploadPass& uploadPass) { if (!texture) { texture = uploadPass.createTexture(*image); } - if (!segments.empty()) { + if (!vertices.empty()) { vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + } + if (!indices.empty()) { indexBuffer = uploadPass.createIndexBuffer(std::move(indices)); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/raster_bucket.hpp b/src/mbgl/renderer/buckets/raster_bucket.hpp index f880903167..0fa3c4299e 100644 --- a/src/mbgl/renderer/buckets/raster_bucket.hpp +++ b/src/mbgl/renderer/buckets/raster_bucket.hpp @@ -37,7 +37,6 @@ public: optional<gfx::VertexBuffer<RasterLayoutVertex>> vertexBuffer; optional<gfx::IndexBuffer> indexBuffer; - const std::string drawScopeID; }; } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp index 694addcc97..96a4c44f08 100644 --- a/src/mbgl/renderer/layers/render_background_layer.cpp +++ b/src/mbgl/renderer/layers/render_background_layer.cpp @@ -7,7 +7,6 @@ #include <mbgl/renderer/image_manager.hpp> #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/programs/programs.hpp> -#include <mbgl/programs/background_program.hpp> #include <mbgl/util/tile_cover.hpp> #include <mbgl/map/transform_state.hpp> #include <mbgl/gfx/cull_face_mode.hpp> @@ -18,7 +17,7 @@ using namespace style; namespace { -inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const BackgroundLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == BackgroundLayer::Impl::staticTypeInfo()); return static_cast<const style::BackgroundLayer::Impl&>(*impl); } @@ -27,13 +26,12 @@ inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& im RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl) : RenderLayer(makeMutable<BackgroundLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderBackgroundLayer::~RenderBackgroundLayer() = default; void RenderBackgroundLayer::transition(const TransitionParameters ¶meters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters ¶meters) { @@ -69,7 +67,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) { const Properties<>::PossiblyEvaluated properties; const BackgroundProgram::Binders paintAttributeData(properties, 0); - auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const UnwrappedTileID& id) { + auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const uint32_t id) { const auto allUniformValues = program.computeAllUniformValues( std::move(uniformValues), paintAttributeData, @@ -88,20 +86,24 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) { parameters.context, *parameters.renderPass, gfx::Triangles(), - parameters.depthModeForSublayer(0, parameters.pass == RenderPass::Opaque - ? gfx::DepthMaskType::ReadWrite - : gfx::DepthMaskType::ReadOnly), + parameters.depthModeForSublayer( + 0, + parameters.pass == RenderPass::Opaque ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly), gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.tileTriangleSegments, + segments, allUniformValues, allAttributeBindings, textureBindings, - getID() + "/" + util::toString(id) - ); + util::toString(id)); }; + + if (segments.empty()) { + segments = parameters.staticData.tileTriangleSegments(); + } + const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated; const auto& crossfade = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade; if (!evaluated.get<BackgroundPattern>().to.empty()) { @@ -113,24 +115,21 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) { if (!imagePosA || !imagePosB) return; + uint32_t i = 0; 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 - ); + 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()}, + }, + i++); } } else { auto backgroundRenderPass = (evaluated.get<BackgroundColor>().a >= 1.0f @@ -139,17 +138,16 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) { if (parameters.pass != backgroundRenderPass) { return; } + uint32_t i = 0; 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 - ); + 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{}, + i++); } } } diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp index dfc2adf76e..dab733172b 100644 --- a/src/mbgl/renderer/layers/render_background_layer.hpp +++ b/src/mbgl/renderer/layers/render_background_layer.hpp @@ -1,5 +1,6 @@ #pragma once +#include <mbgl/programs/background_program.hpp> #include <mbgl/renderer/render_layer.hpp> #include <mbgl/style/layers/background_layer_impl.hpp> #include <mbgl/style/layers/background_layer_properties.hpp> @@ -22,6 +23,7 @@ private: // Paint properties style::BackgroundPaintProperties::Unevaluated unevaluated; + SegmentVector<BackgroundAttributes> segments; }; } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index b88a026e11..e5d7e6230e 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -17,7 +17,7 @@ using namespace style; namespace { -inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const style::CircleLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == CircleLayer::Impl::staticTypeInfo()); return static_cast<const style::CircleLayer::Impl&>(*impl); } @@ -26,11 +26,10 @@ inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl) : RenderLayer(makeMutable<CircleLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} void RenderCircleLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) { diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp index af0bc788d0..4eaec6e55f 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp @@ -23,7 +23,7 @@ using namespace style; namespace { -inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const FillExtrusionLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == FillExtrusionLayer::Impl::staticTypeInfo()); return static_cast<const FillExtrusionLayer::Impl&>(*impl); } @@ -32,13 +32,12 @@ inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl) : RenderLayer(makeMutable<FillExtrusionLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderFillExtrusionLayer::~RenderFillExtrusionLayer() = default; void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) { diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index bbfcef7aba..31b847b6a7 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -24,7 +24,7 @@ using namespace style; namespace { -inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const FillLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == FillLayer::Impl::staticTypeInfo()); return static_cast<const FillLayer::Impl&>(*impl); } @@ -33,13 +33,12 @@ inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl) : RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderFillLayer::~RenderFillLayer() = default; void RenderFillLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) { diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 797aedd297..5f3c36e440 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -4,7 +4,6 @@ #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/programs/programs.hpp> -#include <mbgl/programs/heatmap_program.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/style/layers/heatmap_layer.hpp> #include <mbgl/style/layers/heatmap_layer_impl.hpp> @@ -21,7 +20,7 @@ using namespace style; namespace { -inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) { +inline const HeatmapLayer::Impl& impl_cast(const Immutable<Layer::Impl>& impl) { assert(impl->getTypeInfo() == HeatmapLayer::Impl::staticTypeInfo()); return static_cast<const HeatmapLayer::Impl&>(*impl); } @@ -30,13 +29,13 @@ inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) { RenderHeatmapLayer::RenderHeatmapLayer(Immutable<HeatmapLayer::Impl> _impl) : RenderLayer(makeMutable<HeatmapLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()), colorRamp({256, 1}) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()), + colorRamp({256, 1}) {} RenderHeatmapLayer::~RenderHeatmapLayer() = default; void RenderHeatmapLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); updateColorRamp(); } @@ -177,6 +176,10 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) { checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); + if (segments.empty()) { + // Copy over the segments so that we can create our own DrawScopes. + segments = parameters.staticData.heatmapTextureSegments(); + } programInstance.draw( parameters.context, *parameters.renderPass, @@ -186,15 +189,14 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) { parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.heatmapTextureSegments, + segments, allUniformValues, allAttributeBindings, HeatmapTextureProgram::TextureBindings{ - textures::image::Value{ renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear }, - textures::color_ramp::Value{ colorRampTexture->getResource(), gfx::TextureFilterType::Linear }, + textures::image::Value{renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear}, + textures::color_ramp::Value{colorRampTexture->getResource(), gfx::TextureFilterType::Linear}, }, - getID() - ); + getID()); } } diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp index 1e9b1063ae..b7a03a6ba5 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp @@ -1,10 +1,11 @@ #pragma once +#include <mbgl/gfx/offscreen_texture.hpp> +#include <mbgl/gfx/texture.hpp> +#include <mbgl/programs/heatmap_program.hpp> #include <mbgl/renderer/render_layer.hpp> #include <mbgl/style/layers/heatmap_layer_impl.hpp> #include <mbgl/style/layers/heatmap_layer_properties.hpp> -#include <mbgl/gfx/texture.hpp> -#include <mbgl/gfx/offscreen_texture.hpp> #include <mbgl/util/optional.hpp> namespace mbgl { @@ -24,14 +25,14 @@ private: bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float, const TransformState&, const float, const mat4&, const FeatureState&) const override; + void updateColorRamp(); // Paint properties style::HeatmapPaintProperties::Unevaluated unevaluated; PremultipliedImage colorRamp; std::unique_ptr<gfx::OffscreenTexture> renderTexture; optional<gfx::Texture> colorRampTexture; - - void updateColorRamp(); + SegmentVector<HeatmapTextureAttributes> segments; }; } // namespace mbgl diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp index b570d9c4c9..bf899221f8 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp @@ -20,7 +20,7 @@ using namespace style; namespace { -inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const HillshadeLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == HillshadeLayer::Impl::staticTypeInfo()); return static_cast<const HillshadeLayer::Impl&>(*impl); } @@ -29,8 +29,7 @@ inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& imp RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl) : RenderLayer(makeMutable<HillshadeLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderHillshadeLayer::~RenderHillshadeLayer() = default; @@ -48,7 +47,7 @@ const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& } void RenderHillshadeLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) { @@ -111,21 +110,19 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) { 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) - ); + 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()); }; mat4 mat; @@ -177,29 +174,30 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) { 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() }, - }, - getID() + "/p/" + util::toString(tile.id) - ); + // Copy over the segments so that we can create our own DrawScopes that get destroyed + // after this draw call. + auto segments = parameters.staticData.rasterSegments(); + programInstance.draw(parameters.context, + *renderPass, + gfx::Triangles(), + parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), + gfx::StencilMode::disabled(), + parameters.colorModeForRenderPass(), + gfx::CullFaceMode::disabled(), + *parameters.staticData.quadTriangleIndexBuffer, + segments, + allUniformValues, + allAttributeBindings, + HillshadePrepareProgram::TextureBindings{ + textures::image::Value{bucket.dem->getResource()}, + }, + "prepare"); 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()) { + if (bucket.vertexBuffer && bucket.indexBuffer) { // 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, @@ -211,13 +209,17 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) { }); } else { // 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(); + } draw(parameters.matrixForTile(tile.id, true), *parameters.staticData.rasterVertexBuffer, *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.rasterSegments, + bucket.segments, tile.id, HillshadeProgram::TextureBindings{ - textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear }, + textures::image::Value{bucket.texture->getResource(), gfx::TextureFilterType::Linear}, }); } } diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index 588cf6286c..90bb38b9f9 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -23,7 +23,7 @@ using namespace style; namespace { -inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const LineLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == LineLayer::Impl::staticTypeInfo()); return static_cast<const LineLayer::Impl&>(*impl); } @@ -32,14 +32,13 @@ inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl) : RenderLayer(makeMutable<LineLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()), - colorRamp({256, 1}) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()), + colorRamp({256, 1}) {} RenderLineLayer::~RenderLineLayer() = default; void RenderLineLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); updateColorRamp(); } diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp index 8a1a8a6c28..047333d5e5 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.cpp +++ b/src/mbgl/renderer/layers/render_raster_layer.cpp @@ -16,7 +16,7 @@ using namespace style; namespace { -inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const RasterLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == RasterLayer::Impl::staticTypeInfo()); return static_cast<const RasterLayer::Impl&>(*impl); } @@ -25,13 +25,12 @@ inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl) : RenderLayer(makeMutable<RasterLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderRasterLayer::~RenderRasterLayer() = default; void RenderRasterLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) { @@ -153,14 +152,14 @@ void RenderRasterLayer::render(PaintParameters& parameters) { 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++)); + *bucket.vertexBuffer, + *bucket.indexBuffer, + bucket.segments, + RasterProgram::TextureBindings{ + textures::image0::Value{bucket.texture->getResource(), filter}, + textures::image1::Value{bucket.texture->getResource(), filter}, + }, + std::to_string(i++)); } } else if (renderTiles) { for (const RenderTile& tile : *renderTiles) { @@ -174,28 +173,32 @@ void RenderRasterLayer::render(PaintParameters& parameters) { continue; assert(bucket.texture); - if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) { + if (bucket.vertexBuffer && bucket.indexBuffer) { // 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 }, + textures::image0::Value{bucket.texture->getResource(), filter}, + textures::image1::Value{bucket.texture->getResource(), filter}, }, - bucket.drawScopeID); + "image"); } else { // 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(); + } draw(parameters.matrixForTile(tile.id, true), *parameters.staticData.rasterVertexBuffer, *parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.rasterSegments, + bucket.segments, RasterProgram::TextureBindings{ - textures::image0::Value{ bucket.texture->getResource(), filter }, - textures::image1::Value{ bucket.texture->getResource(), filter }, + textures::image0::Value{bucket.texture->getResource(), filter}, + textures::image1::Value{bucket.texture->getResource(), filter}, }, - bucket.drawScopeID); + "image"); } } } diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp index 955ad2ce51..2a94c452c7 100644 --- a/src/mbgl/renderer/layers/render_symbol_layer.cpp +++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp @@ -290,7 +290,7 @@ void drawText(const DrawFn& draw, } } -inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) { +inline const SymbolLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) { assert(impl->getTypeInfo() == SymbolLayer::Impl::staticTypeInfo()); return static_cast<const SymbolLayer::Impl&>(*impl); } @@ -299,14 +299,14 @@ inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl) : RenderLayer(makeMutable<SymbolLayerProperties>(std::move(_impl))), - unevaluated(impl(baseImpl).paint.untransitioned()) { -} + unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderSymbolLayer::~RenderSymbolLayer() = default; void RenderSymbolLayer::transition(const TransitionParameters& parameters) { - unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); - hasFormatSectionOverrides = SymbolLayerPaintPropertyOverrides::hasOverrides(impl(baseImpl).layout.get<TextField>()); + unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); + hasFormatSectionOverrides = + SymbolLayerPaintPropertyOverrides::hasOverrides(impl_cast(baseImpl).layout.get<TextField>()); } void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) { @@ -314,7 +314,7 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) staticImmutableCast<SymbolLayer::Impl>(baseImpl), unevaluated.evaluate(parameters)); auto& evaluated = properties->evaluated; - auto& layout = impl(baseImpl).layout; + auto& layout = impl_cast(baseImpl).layout; if (hasFormatSectionOverrides) { SymbolLayerPaintPropertyOverrides::setOverrides(layout, evaluated); @@ -346,7 +346,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) { return; } - const bool sortFeaturesByKey = !impl(baseImpl).layout.get<SymbolSortKey>().isUndefined(); + const bool sortFeaturesByKey = !impl_cast(baseImpl).layout.get<SymbolSortKey>().isUndefined(); std::multiset<RenderableSegment> renderableSegments; const auto draw = [¶meters, this] (auto& programInstance, diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp index 6c6abc008b..b2f958b14e 100644 --- a/src/mbgl/renderer/paint_parameters.cpp +++ b/src/mbgl/renderer/paint_parameters.cpp @@ -129,39 +129,30 @@ void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) { const int32_t stencilID = nextStencilID++; tileClippingMaskIDs.emplace(renderTile.id, stencilID); - program.draw( - context, - *renderPass, - gfx::Triangles(), - gfx::DepthMode::disabled(), - gfx::StencilMode { - gfx::StencilMode::Always{}, - stencilID, - 0b11111111, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Replace - }, - gfx::ColorMode::disabled(), - gfx::CullFaceMode::disabled(), - *staticData.quadTriangleIndexBuffer, - staticData.tileTriangleSegments, - program.computeAllUniformValues( - ClippingMaskProgram::LayoutUniformValues { - uniforms::matrix::Value( matrixForTile(renderTile.id) ), - }, - paintAttributeData, - properties, - state.getZoom() - ), - program.computeAllAttributeBindings( - *staticData.tileVertexBuffer, - paintAttributeData, - properties - ), - ClippingMaskProgram::TextureBindings{}, - "clipping/" + util::toString(stencilID) - ); + program.draw(context, + *renderPass, + gfx::Triangles(), + gfx::DepthMode::disabled(), + gfx::StencilMode{gfx::StencilMode::Always{}, + stencilID, + 0b11111111, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Replace}, + gfx::ColorMode::disabled(), + gfx::CullFaceMode::disabled(), + *staticData.quadTriangleIndexBuffer, + staticData.clippingMaskSegments, + program.computeAllUniformValues( + ClippingMaskProgram::LayoutUniformValues{ + uniforms::matrix::Value(matrixForTile(renderTile.id)), + }, + paintAttributeData, + properties, + state.getZoom()), + program.computeAllAttributeBindings(*staticData.tileVertexBuffer, paintAttributeData, properties), + ClippingMaskProgram::TextureBindings{}, + "clipping/" + util::toString(stencilID)); } } diff --git a/src/mbgl/renderer/render_static_data.cpp b/src/mbgl/renderer/render_static_data.cpp index 6378ad9989..f7d9c18a78 100644 --- a/src/mbgl/renderer/render_static_data.cpp +++ b/src/mbgl/renderer/render_static_data.cpp @@ -50,15 +50,37 @@ static gfx::VertexVector<HeatmapTextureLayoutVertex> heatmapTextureVertices() { } RenderStaticData::RenderStaticData(gfx::Context& context, float pixelRatio) - : programs(context, ProgramParameters { pixelRatio, false }) + : programs(context, ProgramParameters{pixelRatio, false}), + clippingMaskSegments(tileTriangleSegments()) #ifndef NDEBUG - , overdrawPrograms(context, ProgramParameters { pixelRatio, true }) + , + overdrawPrograms(context, ProgramParameters{pixelRatio, true}) #endif { - tileTriangleSegments.emplace_back(0, 0, 4, 6); - tileBorderSegments.emplace_back(0, 0, 4, 5); - rasterSegments.emplace_back(0, 0, 4, 6); - heatmapTextureSegments.emplace_back(0, 0, 4, 6); +} + +SegmentVector<BackgroundAttributes> RenderStaticData::tileTriangleSegments() { + SegmentVector<BackgroundAttributes> segments; + segments.emplace_back(0, 0, 4, 6); + return segments; +} + +SegmentVector<DebugAttributes> RenderStaticData::tileBorderSegments() { + SegmentVector<DebugAttributes> segments; + segments.emplace_back(0, 0, 4, 5); + return segments; +} + +SegmentVector<RasterAttributes> RenderStaticData::rasterSegments() { + SegmentVector<RasterAttributes> segments; + segments.emplace_back(0, 0, 4, 6); + return segments; +} + +SegmentVector<HeatmapTextureAttributes> RenderStaticData::heatmapTextureSegments() { + SegmentVector<HeatmapTextureAttributes> segments; + segments.emplace_back(0, 0, 4, 6); + return segments; } void RenderStaticData::upload(gfx::UploadPass& uploadPass) { diff --git a/src/mbgl/renderer/render_static_data.hpp b/src/mbgl/renderer/render_static_data.hpp index 6bf2c846f4..22b29387db 100644 --- a/src/mbgl/renderer/render_static_data.hpp +++ b/src/mbgl/renderer/render_static_data.hpp @@ -30,10 +30,10 @@ public: optional<gfx::IndexBuffer> quadTriangleIndexBuffer; optional<gfx::IndexBuffer> tileBorderIndexBuffer; - SegmentVector<BackgroundAttributes> tileTriangleSegments; - SegmentVector<DebugAttributes> tileBorderSegments; - SegmentVector<RasterAttributes> rasterSegments; - SegmentVector<HeatmapTextureAttributes> heatmapTextureSegments; + static SegmentVector<BackgroundAttributes> tileTriangleSegments(); + static SegmentVector<DebugAttributes> tileBorderSegments(); + static SegmentVector<RasterAttributes> rasterSegments(); + static SegmentVector<HeatmapTextureAttributes> heatmapTextureSegments(); optional<gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer; bool has3D = false; @@ -42,6 +42,8 @@ public: Programs programs; + const SegmentVector<BackgroundAttributes> clippingMaskSegments; + #ifndef NDEBUG Programs overdrawPrograms; #endif diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp index 70db10fa08..ce5fef05b8 100644 --- a/src/mbgl/renderer/render_tile.cpp +++ b/src/mbgl/renderer/render_tile.cpp @@ -147,81 +147,66 @@ void RenderTile::finishRender(PaintParameters& parameters) const { program.draw( parameters.context, *parameters.renderPass, - gfx::Lines { 4.0f * parameters.pixelRatio }, + 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() ) - }, - paintAttributeData, - properties, - parameters.state.getZoom() - ), + program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix), + uniforms::color::Value(Color::white())}, + paintAttributeData, + properties, + parameters.state.getZoom()), allAttributeBindings, DebugProgram::TextureBindings{}, - "__debug/" + debugBucket->drawScopeID + "/text-outline" - ); + "text-outline"); program.draw( parameters.context, *parameters.renderPass, - gfx::Lines { 2.0f * parameters.pixelRatio }, + 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() ) - }, - paintAttributeData, - properties, - parameters.state.getZoom() - ), + program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix), + uniforms::color::Value(Color::black())}, + paintAttributeData, + properties, + parameters.state.getZoom()), allAttributeBindings, DebugProgram::TextureBindings{}, - "__debug/" + debugBucket->drawScopeID + "/text" - ); + "text"); } if (parameters.debugOptions & MapDebugOptions::TileBorders) { assert(debugBucket); + if (debugBucket->tileBorderSegments.empty()) { + debugBucket->tileBorderSegments = parameters.staticData.tileBorderSegments(); + } parameters.programs.debug.draw( parameters.context, *parameters.renderPass, - gfx::LineStrip { 4.0f * parameters.pixelRatio }, + gfx::LineStrip{4.0f * parameters.pixelRatio}, gfx::DepthMode::disabled(), gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), *parameters.staticData.tileBorderIndexBuffer, - parameters.staticData.tileBorderSegments, - program.computeAllUniformValues( - DebugProgram::LayoutUniformValues { - uniforms::matrix::Value( matrix ), - uniforms::color::Value( Color::red() ) - }, - paintAttributeData, - properties, - parameters.state.getZoom() - ), + debugBucket->tileBorderSegments, + program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix), + uniforms::color::Value(Color::red())}, + paintAttributeData, + properties, + parameters.state.getZoom()), program.computeAllAttributeBindings( - *parameters.staticData.tileVertexBuffer, - paintAttributeData, - properties - ), + *parameters.staticData.tileVertexBuffer, paintAttributeData, properties), DebugProgram::TextureBindings{}, - "__debug/" + debugBucket->drawScopeID - ); + "border"); } } diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp index 6d197df9db..30f1bbcee6 100644 --- a/src/mbgl/renderer/sources/render_image_source.cpp +++ b/src/mbgl/renderer/sources/render_image_source.cpp @@ -36,33 +36,25 @@ void ImageSourceRenderData::render(PaintParameters& parameters) const { auto& programInstance = parameters.programs.debug; for (auto matrix : matrices) { - programInstance.draw( - parameters.context, - *parameters.renderPass, - gfx::LineStrip { 4.0f * parameters.pixelRatio }, - gfx::DepthMode::disabled(), - gfx::StencilMode::disabled(), - gfx::ColorMode::unblended(), - gfx::CullFaceMode::disabled(), - *parameters.staticData.tileBorderIndexBuffer, - parameters.staticData.tileBorderSegments, - programInstance.computeAllUniformValues( - DebugProgram::LayoutUniformValues { - uniforms::matrix::Value( matrix ), - uniforms::color::Value( Color::red() ) - }, - paintAttributeData, - properties, - parameters.state.getZoom() - ), - programInstance.computeAllAttributeBindings( - *parameters.staticData.tileVertexBuffer, - paintAttributeData, - properties - ), - DebugProgram::TextureBindings{}, - "image" - ); + programInstance.draw(parameters.context, + *parameters.renderPass, + gfx::LineStrip{4.0f * parameters.pixelRatio}, + gfx::DepthMode::disabled(), + gfx::StencilMode::disabled(), + gfx::ColorMode::unblended(), + gfx::CullFaceMode::disabled(), + *parameters.staticData.tileBorderIndexBuffer, + parameters.staticData.tileBorderSegments(), + programInstance.computeAllUniformValues( + DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix), + uniforms::color::Value(Color::red())}, + paintAttributeData, + properties, + parameters.state.getZoom()), + programInstance.computeAllAttributeBindings( + *parameters.staticData.tileVertexBuffer, paintAttributeData, properties), + DebugProgram::TextureBindings{}, + "image"); } } |